flibberdipper

13 minutes ago, Grumpy Old Man said:

Next step is HDD Swap............

 

I've actually toyed with the idea before but honestly I don't have a need to just because most games I'd play are back compat on the One/Series consoles. The 120GB drive in my Elite is plenty for the games I have (right now), and I plan on eventually replacing it with a 250GB Slim at some point

Though I still haven't ruled out the idea of swapping an SSD into my One X for the memes even though I know I'm just going to replace the ol' girl with a Series X.

6 minutes ago, flibberdipper said:

swapping an SSD into my One X

XBOX ONE HDD............

7 hours ago, Grumpy Old Man said:

XBOX ONE HDD............

  Reveal hidden contents

Xbox One HDD Tools

What this does
Given any HDD over 500GB in size, you can format it for use with your Microsoft Xbox One console
How

Instructions
All of this must be done as root! I HIGHLY suggest you do this on a livecd or usb booted system if you don’t ‘know linux’ and would rather not wipe the
wrong hard drive.
Connect your HDD and take note of what its called (ex: sda, sdb etc)
Run the script with the device name as the first parameter
It will bitch about missing partitions etc, but write a file with commands to create said missing partitions
Run the created script
Copy the correct files to the newly created partitions
Unmount the newly created partitions
Run the main script again
Putting it back together
When you put the new HDD in your console for the first time and boot up, the console will go the the green “Xbox One” screen, pause for a second or
two, then shut down. Boot the console again. This time it should pause at the green screen for a while longer, then go to a black screen for even longer.
It can take several minutes before anything happens after this, the xbox is automatically creating temporary files during this time. If you copied
everything correctly, it WILL go to the dashboard eventually, just be patient!
What is linux?
Wait for a windows version
Required Files
These can be gotten off your original HDD easily
└── [4.0K] System Update
├── [4.0K] A
│ ├── [341M] deltas.xvd
│ ├── [ 36M] SettingsTemplate.xvd
│ ├── [ 24M] sosinit.xvd
│ ├── [ 62M] sostmpl.xvd
│ ├── [267M] systemaux.xvd
│ └── [850M] system.xvd
├── [4.0K] B
│ ├── [ 30M] SettingsTemplate.xvd
│ ├── [ 23M] sosinit.xvd
│ ├── [ 45M] sostmpl.xvd
│ ├── [ 91M] systemaux.xvd
│ └── [761M] system.xvd
└── [ 44M] updater.xvd

--------------------------------------------------------------

gputil.py

 

import struct
import binascii

UNUSED_GUID = '00000000000000000000000000000000'.decode('hex')

def crc2bytes(crc):
    res = ''
    for i in range(4):
        t = crc & 0xFF
        crc >>= 8
        res = '%s%c' % (res, t)
    return res

class Disk(object):
    @classmethod
    def from_path(cls, path, write=False):
        if write:
            return cls(open(path, 'rb+'), write)
        return cls(open(path, 'rb'), write)

    def __init__(self, fobj, write):
        self.lba_size = 512
        self.file = fobj
        self.write = write

    @property
    def header(self):
        if hasattr(self, 'gpt_header'):
            return self.gpt_header
        return self.read_gpt_header()

    @property
    def backup_header(self):
        if hasattr(self, 'gpt_backup_header'):
            return self.gpt_backup_header
        return self.read_gpt_backup_header()

    def commit(self, f=None):
        if not self.write and f is None:
            raise IOError('not allowed to write')

        if f is None:
            f = self.file

        # write header
        self.seek_to_lba(1, f=f)
        f.write(self.header.pack())

        # write partition table
        self.seek_to_lba(self.header.partition_table_lba, f=f)
        f.write(self.header.partition_table.pack())

        # write backup header
        self.seek_to_lba(self.header.backup_lba, f=f)
        f.write(self.backup_header.pack())

        # write backup partition table
        self.seek_to_lba(self.backup_header.partition_table_lba, f=f)
        f.write(self.backup_header.partition_table.pack())

    def dump_to_disk(self, path):
        f = open(path, 'wb')
        f.seek(self.lba_size * self.header.last_lba + self.lba_size - 1)
        f.write('\x00')
        self.commit(f=f)
        f.flush()
        f.close()

    def seek_to_lba(self, lba, f=None):
        if f is not None:
            return f.seek(self.lba_size * lba)
        self.file.seek(self.lba_size * lba)

    def read_gpt_header(self):
        self.seek_to_lba(1)
        self.gpt_header = GPTHeader.from_disk(self)
        return self.gpt_header

    def read_gpt_backup_header(self):
        self.seek_to_lba(self.gpt_header.backup_lba)
        self.gpt_backup_header = GPTHeader.from_disk(self)
        return self.gpt_backup_header

class GPTHeader(object):
    fmt = '< 8s L L 4s L Q Q Q Q 16s Q L L 4s'
    signature = None
    revision = None
    header_size = None
    crc = None
    reserved = None
    current_lba = None
    backup_lba = None
    first_lba = None
    last_lba = None
    disk_guid = None
    partition_table_lba = None
    partition_table_size = None
    partition_table_entry_size = None
    partition_table_crc = None

    @classmethod
    def from_disk(cls, disk):
        o = cls()
        o.disk = disk
        (o.signature, o.revision, o.header_size, o.crc, o.reserved,
            o.current_lba, o.backup_lba, o.first_lba, o.last_lba, o.disk_guid,
            o.partition_table_lba, o.partition_table_size,
            o.partition_table_entry_size, o.partition_table_crc
        ) = struct.unpack(cls.fmt, disk.file.read(struct.calcsize(cls.fmt)))
        return o

    @property
    def partition_table(self):
        if hasattr(self, 'gpt_partition_table'):
            return self.gpt_partition_table
        return self.read_gpt_partition_table()

    def pack(self, use_crc=True):
        o = self
        crc = o.crc if use_crc else '\x00\x00\x00\x00'
        return struct.pack(self.fmt, o.signature, o.revision,
            o.header_size, crc, o.reserved, o.current_lba, o.backup_lba,
            o.first_lba, o.last_lba, o.disk_guid, o.partition_table_lba,
            o.partition_table_size, o.partition_table_entry_size,
            o.partition_table_crc)

    def calculate_crc(self):
        data = self.pack(use_crc=False)
        return crc2bytes(binascii.crc32(data))

    def check_crc(self):
        return self.crc == self.calculate_crc()

    def fix_crc(self):
        self.partition_table_crc = self.partition_table.calculate_crc()
        self.crc = self.calculate_crc()

    def read_gpt_partition_table(self):
        self.disk.seek_to_lba(self.partition_table_lba)
        self.gpt_partition_table = GPTPartitionTable.from_header(self)
        return self.gpt_partition_table

class GPTPartitionTable(object):
    def __init__(self):
        self.partitions = []

    @classmethod
    def from_header(cls, header):
        o = cls()
        o.header = header
        for i in range(header.partition_table_size):
            data = header.disk.file.read(header.partition_table_entry_size)
            o.partitions.append(GPTPartition.from_table(o, data))
        return o

    @property
    def active_partitions(self):
        active = []
        for part in self.partitions:
            if part.type_guid == UNUSED_GUID:
                break
            active.append(part)
        return active

    def pack(self):
        return ''.join([p.pack() for p in self.partitions])

    def calculate_crc(self):
        data = self.pack()
        return crc2bytes(binascii.crc32(data))

    def check_crc(self):
        return self.header.partition_table_crc == self.calculate_crc()

class GPTPartition(object):
    fmt = '< 16s 16s Q Q Q 72s'
    type_guid = None
    part_guid = None
    first_lba = None
    last_lba = None
    flags = None
    name = None

    @classmethod
    def from_table(cls, table, data):
        o = cls()
        o.table = table
        (o.type_guid, o.part_guid, o.first_lba,
            o.last_lba, o.flags, o.name) = struct.unpack(cls.fmt, data)
        o.name = o.name.decode('utf-16le')
        if '\x00' in o.name:
            o.name = o.name[:o.name.find('\x00')]
        return o

    def pack(self):
        o = self
        return struct.pack(self.fmt, o.type_guid, o.part_guid, o.first_lba,
            o.last_lba, o.flags, o.name.encode('utf-16le'))

    @property
    def size(self):
        lba_size = self.last_lba - self.first_lba + 1
        return lba_size * self.table.header.disk.lba_size
        
--------------------------------------------------------------------------------------

xboxonehdd.py

 

#!/usr/bin/python

import os
from stat import *
from os import path
import sys
import gptutil

DISK_GUID           = 'DB4B34A2DED666479EB54109A12228E5'.decode('hex')
TEMP_CONTENT_GUID   = 'A57D72B3ACA33D4B9FD62EA54441011B'.decode('hex')
USER_CONTENT_GUID   = 'E0B59B865633E64B85F729323A675CC7'.decode('hex')
SYSTEM_SUPPORT_GUID = '477A0DC9B9CCBA4C8C660459F6B85724'.decode('hex')
SYSTEM_UPDATE_GUID  = 'D76A059AED324141AEB1AFB9BD5565DC'.decode('hex')
SYSTEM_UPDATE2_GUID = '7C19B224019DF945A8E1DBBCFA161EB2'.decode('hex')

PARTITION_SIZES = [
    44023414784,
    0,
    42949672960,
    12884901888,
    7516192768
]

def print_parted_commands(device):
    temp_end = 1 + (PARTITION_SIZES[0]/1024/1024)
    user_end = temp_end + (PARTITION_SIZES[1]/1024/1024)
    sys_end = user_end + (PARTITION_SIZES[2]/1024/1024)
    upt_end = sys_end + (PARTITION_SIZES[3]/1024/1024)
    upt2_end = upt_end + (PARTITION_SIZES[4]/1024/1024)

    f = open('mkxboxfs.sh', 'w')
    f.write('#!/bin/bash\n')
    f.write('DEV={0}\n'.format(device))
    f.write('parted -s "$DEV" mktable gpt\n')
    f.write('parted -s "$DEV" mkpart primary ntfs 1.00MiB {0}MiB\n'.format(temp_end))
    f.write('parted -s "$DEV" name 1 "\\"Temp Content\\""\n')
    f.write('mkntfs -q "${DEV}1" -f -L "Temp Content"\n')
    f.write('parted -s "$DEV" mkpart primary ntfs {0}MiB {1}MiB\n'.format(temp_end, user_end))
    f.write('parted -s "$DEV" name 2 "\\"User Content\\""\n')
    f.write('mkntfs -q "${DEV}2" -f -L "User Content"\n')
    f.write('parted -s "$DEV" mkpart primary ntfs {0}MiB {1}MiB\n'.format(user_end, sys_end))
    f.write('parted -s "$DEV" name 3 "\\"System Support\\""\n')
    f.write('mkntfs -q "${DEV}3" -f -L "System Support"\n')
    f.write('parted -s "$DEV" mkpart primary ntfs {0}MiB {1}MiB\n'.format(sys_end, upt_end))
    f.write('parted -s "$DEV" name 4 "\\"System Update\\""\n')
    f.write('mkntfs -q "${DEV}4" -f -L "System Update"\n')
    f.write('parted -s "$DEV" mkpart primary ntfs {0}MiB {1}MiB\n'.format(upt_end, upt2_end))
    f.write('parted -s "$DEV" name 5 "\\"System Update 2\\""\n')
    f.write('mkntfs -q "${DEV}5" -f -L "System Update 2"\n')
    f.flush()
    f.close()
    os.chmod('mkxboxfs.sh', 0o777)

def fixup_header(hdr):
    hdr.disk_guid = DISK_GUID
    hdr.fix_crc()

def fixup_part_table(pt):
    pt.partitions[0].part_guid = TEMP_CONTENT_GUID
    pt.partitions[0].name = u'Temp Content'
    pt.partitions[1].part_guid = USER_CONTENT_GUID
    pt.partitions[1].name = u'User Content'
    pt.partitions[2].part_guid = SYSTEM_SUPPORT_GUID
    pt.partitions[2].name = u'System Support'
    pt.partitions[3].part_guid = SYSTEM_UPDATE_GUID
    pt.partitions[3].name = u'System Update'
    pt.partitions[4].part_guid = SYSTEM_UPDATE2_GUID
    pt.partitions[4].name = u'System Update 2'

if __name__ == '__main__':
    if len(sys.argv) != 2:
        print 'Usage:'
        print '\t{0} [disk]'.format(sys.argv[0])
        print 'Example:'
        print '\t{0} sdf'.format(sys.argv[0])
        print
        sys.exit(-1)

    # open the disk
    _path = path.join('/dev', sys.argv[1])
    disk = gptutil.Disk.from_path(_path)
    partitions = disk.header.partition_table.active_partitions

    # calculate user partition size to nearest GiB
    total_size = int(open(path.join('/sys', 'class', 'block', sys.argv[1], 'size'), 'r').readline()) * 512
    user_content_size = (total_size - sum(PARTITION_SIZES))/1024/1024/1024
    PARTITION_SIZES[1] = user_content_size*1024*1024*1024

    # verify partition count
    if len(partitions) != 5:
        print 'Disk must have 5 partitions'
        print 'Create as follows:'
        print '\t41 GiB NTFS'
        print '\t{0} GiB NTFS'.format(user_content_size)
        print '\t40 GiB NTFS'
        print '\t12 GiB NTFS'
        print '\t7 GiB NTFS'
        print_parted_commands(_path)
        print 'run ./mkxboxfs.sh to create the correct partitions'
        sys.exit(-2)

    # verify partition sizes
    for i in range(5):
        correct = PARTITION_SIZES
        actual = partitions.size
        if correct != actual:
            print 'Partition {0} must be EXACTLY {1} bytes!'.format(i, correct)
            print 'It is {0} bytes'.format(actual)
            print_parted_commands(_path)
            print 'run ./mkxboxfs.sh to create the correct partitions'
            sys.exit(-3)

    # confirm actions
    print 'The actions performed CANNOT be reversed!'
    print 'Are you SURE you want to convert {0} to an Xbox ONE Disk?'.format(_path)
    s = raw_input("Enter 'yes' to continue: ")
    if s != 'yes':
        sys.exit(-4)

    # change partition table and backup partition table
    fixup_part_table(disk.header.partition_table)

    # change header and backup header
    fixup_header(disk.header)

    print 'Writing changes to disk...'
    diskf = open(_path, 'rb+')
    disk.commit(f=diskf)
    print 'Changes Written!'       

 

It's really not that hard anymore. In theory you can swap another drive in, slap the firmware on a flash drive, and let 'er eat.