Bryson mentioned Docstrings in the latest episode of the MacAdmins Podcast. But how do you use them? Documentation strings (or docstrings for short) are an easy way to document Python objects (classes, functions, methods, and modules in-line with your code. Docstrings are created using three double-quotes in the first
statement of the definition and are meant to describe in a human readable way what the object does.
Let’s look at an example for hello_krypted:
"""This simply echos Hello Krypted.
But there's so much potential to do more!
Docstrings can then be accessed using the __doc__ attribute on objects (e.g. via print):
>>> print hello_krypted.__doc__
This simply echos Hello Krypted.
But you can say hello in person!
For more on docstrings, check out the official docs at https://www.python.org/dev/peps/pep-0257/
krypted June 25th, 2018
Posted In: Programming, Python
krypted May 9th, 2018
Posted In: Uncategorized
Migrating file services from a macOS Server to a macOS Client can be a bit traumatic at first. Mostly because the thought itself can be a bit daunting. But once you get started, it’s pretty simple. Mostly because there’s less to do. And that can be a challenge. While there are ways to hack together solutions for network homes and other more advanced features, if you’re doing that, then you’re missing a key point here.
Let’s start by documenting our existing share points. We’ll do this with the serveradmin command and using the settings verb for the sharing service as follows:
sudo serveradmin settings sharing
Each share is an item in the sharePointList array, with the following:
sharing:sharePointList:_array_id:/Users/charles.edge/Public:nfsExportRecord = _empty_array
sharing:sharePointList:_array_id:/Users/charles.edge/Public:smbName = “Charles Edge’s Public Folder”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:name = “Charles Edge’s Public Folder”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:afpIsGuestAccessEnabled = yes
sharing:sharePointList:_array_id:/Users/charles.edge/Public:isIndexingEnabled = no
sharing:sharePointList:_array_id:/Users/charles.edge/Public:dsAttrTypeNative\:sharepoint_group_id = “6C37A421-C506-4523-8769-1AF6EA245B68”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:mountedOnPath = “/”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:dsAttrTypeNative\:sharepoint_account_uuid = “C0405AE4-6CBE-40C7-9584-174687C80C07”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:path = “/Users/charles.edge/Public”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:smbIsShared = yes
sharing:sharePointList:_array_id:/Users/charles.edge/Public:smbIsGuestAccessEnabled = yes
sharing:sharePointList:_array_id:/Users/charles.edge/Public:afpName = “Charles Edge’s Public Folder”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:dsAttrTypeStandard\:GeneratedUID = “5C13E2AA-A86D-45D0-80B4-00CA86DE2253”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:smbDirectoryMask = “755”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:afpIsShared = yes
sharing:sharePointList:_array_id:/Users/charles.edge/Public:smbCreateMask = “644”
sharing:sharePointList:_array_id:/Users/charles.edge/Public:ftpName = “Charles Edge’s Public Folder”
Once you’ve removed the Server app, you’ll be left with using the sharing command. Using that command, you can list shares using the -l option:
That same share then appears as follows:
List of Share Points
name: Charles Edge’s Public Folder
name: Charles Edge’s Public Folder
guest access: 1
inherit perms: 0
name: Charles Edge’s Public Folder
guest access: 1
Or from the Sharing System Preference Pane.
Now you just have to loop through and create each share (although they should co-exist between tools). To create a share, click on the plus sign under Shared Folders.
You can then browse to the folder you’d like to share. Next, we’ll give access to the directory. Use the plus sign on the right side of the screen and then select the user or group you’d like to add to the list that has access to the directory (while the directory is highlighted in the list on the left).
Once the user is in the list, use the permissions on the right side of the user list to select what level each user or group gets.
You have additional controls for file and folder security that can be set at either the directory that is shared or those below it hierarchically. To do so, highlight the directory and use the Get Info option under the File menu in the Finder.
Note: You can also check the Shared Folder box on these folders to share them, meaning you have one less step once you get used to the workflow!
krypted April 25th, 2018
Posted In: Mac OS X
macos, macos server, network home directories, pwd, replace file server, setup file shares, Sharing
Awhile back, I wrote a tool to rewrap ipa files that I called ipasign: https://github.com/krypted/ipasign/blob/master/ipasign.py
. But I wanted to do something similar for the Mac, and specifically have it run in Linux. So looking at what you’d need to be able to do, let’s start with viewing the contents of a flattened Apple package. This command will show you the files installed as a part of the Node JS package. Why did I choose that package? It was sitting on my desktop…
pkgutil --files org.nodejs.node.pkg
Now, this logic is available because you’re running pkgutil on a Mac. But that can’t run in Linux. So what would you do if you wanted to complete that same operation? If the package hasn’t been flattened then you can simply traverse the files in the package. If it has been flattened (and it must be in order to properly be signed) then that can’t work. So to see the files installed from a Linux system will require a tad bit more work. First, we’ll create a directly to extract our package into:
Then cd into that directory and use xar to extract the package:
xar -xf /Users/charles.edge/Downloads/node-v8.11.1.pkg
In there, you’ll see three files: Bom, PackageInfo, and Payload. The contents, which mimic the –files option to some extent are found by first changing the name of payload to Payload.gz:
mv ./node-v8.11.1.pkg/Payload ./node-v8.11.1.pkg/Payload.gz
Then unzipping it:
And viewing the contents:
cpio -iv < Payload
Or throw all that into a one-liner:
cpio -o | gzip -c > Payload
You can also use bomutils to traverse and make BOMs: http://bomutils.dyndns.org/tutorial.html
You can also see some metadata about how the package will lay down by catting the distribution file:
<?xml version=”1.0″ encoding=”utf-8″ standalone=”yes”?>
<background alignment=”topleft” file=”osx_installer_logo.png”/>
<pkg-ref id=”org.nodejs.node.pkg” auth=”root”>
<pkg-ref id=”org.nodejs.npm.pkg” auth=”root”>
<options customize=”allow” require-scripts=”false”/>
<choice id=”org.nodejs.node.pkg” visible=”true” title=”Node.js v8.11.1″>
<pkg-ref id=”org.nodejs.node.pkg” version=”v8.11.1″ onConclusion=”none” installKBytes=”37377″>#node-v8.11.1.pkg</pkg-ref>
<choice id=”org.nodejs.npm.pkg” visible=”true” title=”npm v5.6.0″>
<pkg-ref id=”org.nodejs.npm.pkg” version=”v5.6.0″ onConclusion=”none” installKBytes=”20113″>#npm-v5.6.0.pkg</pkg-ref>
If you want to make a package, check out this gist: https://gist.github.com/SchizoDuckie/2a1a1cc71284e6463b9a
Next up, you frequently want to check the signature of a package. So to see the signature, I can simply use: pkgutil if on a Mac:
pkgutil --check-signature org.nodejs.node.pkg
Or I can use codesign:
codesign -v node-v8.11.1.pkg
The beauty of codesign is that it’s been open sourced by Apple
. The bummer about codesign is that it uses multiple CoreFoundation frameworks:
otool -L /usr/bin/codesign
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (compatibility version 150.0.0, current version 1452.23.0)
/System/Library/Frameworks/Security.framework/Versions/A/Security (compatibility version 1.0.0, current version 58286.51.6)
/usr/lib/libc++.1.dylib (compatibility version 1.0.0, current version 400.9.0)
/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1252.50.4)
krypted April 24th, 2018
Posted In: Mac OS X, Mac Security, Mass Deployment
binary packages, codesign, cpio, flatten, inspect and edit apple pkg files, Linux, Mac packages on linux
Since some of the more interesting features of Time Machine Server are gone, let’s talk about doing even more than what was previously available in that interface by using the command line to access Time Machine.
As with any other command, you should probably start by reading the man page. For Time Machine, that would be:
Sometimes, the incantation of the command you’re looking for might even be available at the bottom of the man page. Feel free to use the space bar a few times to skip to the bottom, or q to quit the man interface.
In addition to the man page, there’s a help command, which can be used in conjunction with any of the command verbs (which makes me think of “conjunction junction, what’s your function”). For example, you can tell tmutil to compare backups using the compare verb. To see more on the usage of the compare verb, use tmutil followed by compare (the verb, or action you wish the command to perform), followed by help:
/usr/bin/tmutil compare help
Before you start using Time Machine, you’ll want to set a backup source and destination. Before you do, check the destination that’s configured:
The output will include
Once you’ve checked the destination, you can set a destination. For example, the most common destination will be something like /Volumes/mybackupdrive where mybackupdrive is a drive you plugged into your computer for Time Machine.
sudo /usr/bin/tmutil setdestination /Volumes/mybackupdrive
Once you’ve configured a destination for your backups, it’s time to enable Time Machine. The simplest verbs to use are going to be the enable and disable verbs, which you might guess turn Time Machine on and off respectively. For these, you’ll need elevated privileges. To turn Time Machine on:
sudo /usr/bin/tmutil enable
To then disable Time Machine:
sudo /usr/bin/tmutil disable
You can also kick off a backup manually. To do so, use the startbackup verb as follows:
sudo /usr/bin/tmutil startbackup
To see the status, once you’ve kicked off a backup (this one is gonna’ be hard to remember) use the status verb:
sudo /usr/bin/tmutil status
Or to stop a backup that is running (e.g. if your computer is running slowly and you think it’s due to a backup running), you’d use the stopbackup verb:
sudo tmutil stopbackup
Once backups are complete, you can see the directory they’re being stored in with the machinedirectory verb. This will become important when we go to view information about backups and compare backups, which require that directory to be available as those options check local files and databases for information directly. The tmutil verb to do that is machinedirectory:
sudo /usr/bin/tmutil machinebackup
Other options you can enable, include the ability to exclude files or directories from your backups. For example, you won’t likely want to backup your music or movies that were purchased on iTunes as they take up a lot of space and are dynamically restored from Apple in the event that such a restore is necessary. The verb to do so is addexclusion and this also requires sudo. So to exclude the user krypted’s ~/Music directory, you’d use a command as follows:
sudo /usr/bin/tmutil addexclusion /Users/krypted/Music
To then check if a directory is excluded, use the isexcluded verb and define the path:
sudo /usr/bin/tmutil isexcluded /Users/krypted/Music
If you make an errant exclusion do the opposite to remove, leveraging the removeexclusion verb:
/usr/bin/tmutil removeexclusion /Users/krypted/Music
Once a backup is complete, you can also check various information about the backups. This can be done using a few different verbs. One of the more common manual tasks that is run is listing the recent backups that can be restored. This is done using the listbackups verb with no operators (the backup directory needs to be available when run, so cd into that before using listbackups).
You can also view the latest backup, which can then be grabbed by your management tool, which is provided in the YYYY-MM-DD-HHMMSS format.
You can also compare backups so you can see the files that have been changed, added, and removed, as well as the size of the drift between the two backups. To do so, use the compare verb and provide the paths between the two backups that were obtained when using the listbackups verb, as follows:
/usr/bin/tmutil compare “/Volumes/mybackupdrive/Backups.backupdb/Krypted/2018–04–24–051014” “/Volumes/mybackupdrive/Backups.backupdb/Krypted/2018–04–24–061015”
In the above paths, we’re using the mybackupdrive and krypted is the source volume name. You can also look at all of the backups (and potentially derive future space requirements based on a trend line) by using the calculatedrift verb:
/usr/bin/tmutil calculatedrift /Volumes/mybackupdrive/Backups.backupdb/Krypted
At times, you may end up replacing infrastructure. So you might move backups to a new location, or move backups to a new solution. You can use the inherent backups to claim a new machine directory. So if you moved your backups from /Volumes/mybackupdrive/Backups.backupdb/Krypted to /Volumes/mylargerbackupdrive/Backups.backupdb/Krypted during an upgrade you might run the following so you don’t have to start backing up all over again and end up wiping out your backup history:
/usr/bin/tmutil inheritbackup /Volumes/mylargerbackupdrive/Backups.backupdb/Krypted
Or if you have both available at once, use the associatedisk verb with the new volume followed by the old volume:
sudo /usr/bin/tmutil associatedisk "/Volumes/mylargerbackupdrive/Backups.backupdb/Krypted" "/Volumes/mybackupdrive/Backups.backupdb/Krypted"
Or if you do want to start over but want to clear out old backups, you can use the delete verb followed by the path to the backup or snapshot, as follows:
sudo /usr/bin/tmutil delete /Volumes/mybackupdrive/Backups.backupdb/Krypted
There are also a few more verbs available, mostly for apfs. The localsnapshot command creates new snapshots of APFS volumes, and is used with no operators, as follows:
sudo /usr/bin/tmutil localsnapshot
To then see the snapshots, use the listlocalsnapshots verb,
sudo /usr/bin/tmutil listlocalsnapshots
Which outputs as follows:
Or to constrain the output for easier parsing, use listlocalsnapshotdates:
sudo /usr/bin/tmutil listlocalsnapshotdates
Which outputs as follows
And you can delete a snapshot with the deletesnapshot
sudo tmutil deletelocalsnapshots 2018-04-20-061417
Now, thinning out your backups is always an interesting task. And in my experience your mileage may vary. Here, you can use the thinlocalsnapshots verb to prune the oldest data from backups. In the following example, we’re going to purge 10 gigs of data:
sudo /usr/bin/tmutil thinlocalsnapshots / 10000000000
Finally, let’s talk about automated restores. You could use this type of technology to do a rudimentary form of imaging or rolling users into a new machine. To restore a backup, you would use the (shocking here) restore verb. First, let’s look at restoring a single file. In the following example, we’ll restore a file called mysuperimportantfile from a computer called mycomputername and provide the date of the snapshot we’re restoring from:
sudo /usr/bin/tmutil restore /Volumes/mybackupdrive/Backups.backupdb/mycomputername/2018-04-24-051015/Macintosh\ HD/Users/krypted/Desktop/mysuperimportantfile
Now, let’s look at restoring a volume. Here, we’re going to change our working directory to the root of our latest backup, not booted to the volume we’re about to erase and overwrite with a backup):
cd "/Volumes/Time Machine Backup Disk/Backups.backupdb/mycomputername/Latest/Macintosh HD"
And then (this is dangerous, as it wipes out what’s on the old volume with the backed up data):
sudo /usr/bin/tmutil restore -v "/Volumes/Time Machine Backup Disk/Backups.backupdb/mycomputername/Latest/Macintosh HD" "/Volumes/Macintosh HD"
Now, let’s talk about what’s realistic. If I were to programmatically erase one of my coworkers data. I’d really, really want to verify that everything they need is there. So I’d run a checksum against the source and keep a copy of it only once I verify that absolutely everything is going where I want it to go. I would trust a cloning tool, but would I want to basically write my own archival solution using tmutil? No. I’ve simply seen too many strange little tidbits here and there that make me not… exactly… trust it with other people’s data. With my own data, though… sure! <3
krypted April 23rd, 2018
Posted In: Mac OS X, Mac OS X Server, Mac Security
startbackup, stopbackup, tmutil, tmutil calculatedrift, tmutil enable
The msiexec command can be used to run an installer on Windows in a zero touch fashion. To do so, run the following command:
msiexec /i "python-2.7.14.amd64.msi" /passive TARGETDIR="C:\python"
krypted April 22nd, 2018
Posted In: Windows Server
Command line, install python on windows, Shell
Synology provides SSH access, which allows you to do a number of things you can’t do with the GUI. To enable SSH, simply log in on the Synology and open Control Panel. From the Control Panel, scroll down to “Terminal & SNMP” in the sidebar and check the box for “Enable SSH service” and then click Apply.
The device will then have SSH enabled. Open Terminal on your Mac or Windows device and let’s SSH into the root account of the IP address, done as follows (where 192.168.50.5 is the IP address of your Synology):
When prompted, enter the same admin password you normally use. You’ll then be at a command prompt in the device, which should look like this:
Now, you can cd around, use ls to view folder contents. Terminal substitutions like !$ and !! won’t work, but you can do simple tasks like restart services using the synoservice command:
/usr/syno/sbin/synoservice –restart <servicename>
krypted April 16th, 2018
Posted In: Synology
enable SSH, enable ssh on a synology, get ssh access
A Synology can act as a local file server that is used to share a folder from a cloud account. You can use accounts with from Backblaze, Google Drive, Amazon, Alibaba, Dropbox, Azure, and others. This means you can use a Synology to provide LAN access to cloud solutions. Before you do, make sure you understand that if changes are made in the cloud and on a client computer at the same time, that you will end up not knowing which is right and so file-locking issues will come up. It’s best to use this strategy for home environments or come up with another mechanism for locking files.
If you choose to use the sync option, open Package Center and search for Cloud Sync.
Click Install to install the package.
Once installed, choose the cloud you’d like to sync to your local network.
For this example, we’ll use Google Drive. Click on that option and then when prompted, select the account to use (if you have multiple accounts you access).
Once you’ve selected an account, you need to give an entitlement to the Synology to sync with that api.
When prompted, click Agree.
Next, configure how the data will be stored on the Synology. Do so by providing a name to the connection and choosing a path on your local storage.
You can also create a folder on the Synology to then share. We’ll do so here and then click OK.
Then select .which folder on your cloud volume (in this case, my Google Drive) that you want to sync and click Select.
Select when the sync will run. In this example, every hour.
Click OK and then Next. You’ll be shown an overview of the options you selected. Click Apply.
And then the first sync will start.
While the sync is running, let’s click Settings and review the options for throttling speeds (so as not to destroy slower WAN links).
Click History to see logs. And viola, you now have a local copy of cloud accounts!
krypted April 15th, 2018
Posted In: Synology
backup, cloud backup, cloud sync, Synology
Carbonite is a great tool for backing up Macs and Windows devices. To install Carbonite, download it from www.carbonite.com
. Once downloaded, copy the app to the /Applications directory and open the app.
The Carbonite app will then install the components required to support the backup operations and index the drive.
Next, you’ll see some basic folders that will be backed up. Check the box for those you want to add to the backup (or do this later) and click the Install button.
Click Open Carbonite.
Notice that the backup has begun! The only really customer-installable action is to select the directories to be backed up, which is done using the left-hand sidebar.
And that’s it. There aren’t a lot of other options in the GUI. You can access more options at /Library/Preferences/com.carbonite.carbonite.plist.
krypted April 12th, 2018
Posted In: Mac OS X
backup macOS, carbonite, macos
Next Page »
The DNS service in macOS Server was simple to setup and manage. It’s a bit more manual in macOS without macOS Server. The underlying service that provides DNS is Bind. Bind will require a compiler to install, so first make sure you have the Xcode command line tools installed. To download Bind, go to ISC at https://www.isc.org/downloads/. From there, copy the installer locally and extract the tar file. Once that’s extracted, run the configure from within the extracted directory:
./configure --enable-symtable=none --infodir="/usr/share/info" --sysconfdir="/etc" --localstatedir="/var" --enable-atomic="no" --with-gssapi=yes --with-libxml2=no
Next, run make:
Then run make install:
Now download a LaunchDaemon plist (I just stole this from the org.isc.named.plist on a macOS Server, which can be found at /Applications/Server.app/Contents/ServerRoot/System/Library/LaunchDaemons/org.isc.named.plist or downloaded using that link). The permissions for a custom LaunchDaemon need to be set appropriately:
chmod root:wheel /Library/LaunchDaemons/org.isc.named.plist
Then start it up and test it!
krypted April 11th, 2018
Posted In: Mac OS X, Mac OS X Server
install bind, MAC, macos, os x, replace macOS server