macOS Objective-C - HackTricks

# macOS Objective-C

> [!TIP] Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
> Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

> Support HackTricks
> - Check the subscription plans!
> - Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.
> - Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.

## Objective-C

> [!CAUTION] Note that programs written in Objective-C retain their class declarations when compiled into Mach-O binaries. Such class declarations include the name and type of:

- The class
- The class methods
- The class instance variables

You can get this information using class-dump:

    class-dump Kindle.app

Note that this names could be obfuscated to make the reversing of the binary more difficult.

## Classes, Methods & Objects

### Interface, Properties & Methods

    // Declare the interface of the class
    @interface MyVehicle : NSObject

    // Declare the properties
    @property NSString *vehicleType;
    @property int numberOfWheels;

    // Declare the methods
    - (void)startEngine;
    - (void)addWheels:(int)value;

    @end

### Class

    @implementation MyVehicle : NSObject

    // No need to indicate the properties, only define methods

    - (void)startEngine {
        NSLog(@"Engine started");
    }

    - (void)addWheels:(int)value {
        self.numberOfWheels += value;
    }

    @end

### Object & Call Method

To create an instance of a class the `alloc` method is called which allocate memory for each property and zero those allocations. Then `init` is called, which initilize the properties to the required values.

    // Something like this:
    MyVehicle *newVehicle = [[MyVehicle alloc] init];

    // Which is usually expressed as:
    MyVehicle *newVehicle = [MyVehicle new];

    // To call a method
    // [myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]
    [newVehicle addWheels:4];

### Class Methods

Class methods are defined with the plus sign (+) not the hyphen (-) that is used with instance methods. Like the NSString class method `stringWithString`:

    + (id)stringWithString:(NSString *)aString;

### Setter & Getter

To set & get properties, you could do it with a dot notation or like if you were calling a method:

    // Set
    newVehicle.numberOfWheels = 2;
    [newVehicle setNumberOfWheels:3];

    // Get
    NSLog(@"Number of wheels: %i", newVehicle.numberOfWheels);
    NSLog(@"Number of wheels: %i", [newVehicle numberOfWheels]);

### Instance Variables

Alternatively to setter & getter methods you can use instance variables. These variables have the same name as the properties but starting with a "_":

    - (void)makeLongTruck {
        _numberOfWheels = +10000;
        NSLog(@"Number of wheels: %i", self.numberOfLeaves);
    }

### Protocols

Protocols are set of method declarations (without properties). A class that implements a protocol implement the declared methods.

There are 2 types of methods: mandatory and optional. By default a method is mandatory (but you can also indicate it with a `@required` tag). To indicate that a method is optional use `@optional`.

    @protocol myNewProtocol
    - (void) method1; //mandatory
    @required
    - (void) method2; //mandatory
    @optional
    - (void) method3; //optional
    @end

### All together

    // gcc -framework Foundation test_obj.m -o test_obj
    #import <Foundation/Foundation.h>

    @protocol myVehicleProtocol
    - (void) startEngine; //mandatory
    @required
    - (void) addWheels:(int)value; //mandatory
    @optional
    - (void) makeLongTruck; //optional
    @end

    @interface MyVehicle : NSObject <myVehicleProtocol>

    @property int numberOfWheels;

    - (void)startEngine;
    - (void)addWheels:(int)value;
    - (void)makeLongTruck;

    @end

    @implementation MyVehicle : NSObject

    - (void)startEngine {
        NSLog(@"Engine started");
    }

    - (void)addWheels:(int)value {
        self.numberOfWheels += value;
    }

    - (void)makeLongTruck {
        _numberOfWheels = +10000;
        NSLog(@"Number of wheels: %i", self.numberOfWheels);
    }

    @end

    int main() {
        MyVehicle* mySuperCar = [MyVehicle new];
        [mySuperCar startEngine];
        mySuperCar.numberOfWheels = 4;
        NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels);
        [mySuperCar setNumberOfWheels:3];
        NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels);
        [mySuperCar makeLongTruck];
    }

### Basic Classes

#### String

    // NSString
    NSString *bookTitle = @"The Catcher in the Rye";
    NSString *bookAuthor = [[NSString alloc] initWithCString:"J.D. Salinger" encoding:NSUTF8StringEncoding];
    NSString *bookPublicationYear = [NSString stringWithCString:"1951" encoding:NSUTF8StringEncoding];

Basic classes are immutable, so to append a string to an existing one a new NSString needs to be created.

    NSString *bookDescription = [NSString stringWithFormat:@"%@ by %@ was published in %@", bookTitle, bookAuthor, bookPublicationYear];

Or you could also use a mutable string class:

    NSMutableString *mutableString = [NSMutableString stringWithString:@"The book "];
    [mutableString appendString:bookTitle];
    [mutableString appendString:@" was written by "];
    [mutableString appendString:bookAuthor];
    [mutableString appendString:@" and published in "];
    [mutableString appendString:bookPublicationYear];

#### Number

    // character literals.
    NSNumber *theLetterZ = @'Z'; // equivalent to [NSNumber numberWithChar:'Z']

    // integral literals.
    NSNumber *fortyTwo = @42; // equivalent to [NSNumber numberWithInt:42]
    NSNumber *fortyTwoUnsigned = @42U; // equivalent to [NSNumber numberWithUnsignedInt:42U]
    NSNumber *fortyTwoLong = @42L; // equivalent to [NSNumber numberWithLong:42L]
    NSNumber *fortyTwoLongLong = @42LL; // equivalent to [NSNumber numberWithLongLong:42LL]

    // floating point literals.
    NSNumber *piFloat = @3.141592654F; // equivalent to [NSNumber numberWithFloat:3.141592654F]
    NSNumber *piDouble = @3.1415926535; // equivalent to [NSNumber numberWithDouble:3.1415926535]

    // BOOL literals.
    NSNumber *yesNumber = @YES; // equivalent to [NSNumber numberWithBool:YES]
    NSNumber *noNumber = @NO; // equivalent to [NSNumber numberWithBool:NO]

#### Array, Sets & Dictionary

    // Inmutable arrays
    NSArray *colorsArray1 = [NSArray arrayWithObjects:@"red", @"green", @"blue", nil];
    NSArray *colorsArray2 = @[@"yellow", @"cyan", @"magenta"];
    NSArray *colorsArray3 = @[firstColor, secondColor, thirdColor];

    // Mutable arrays
    NSMutableArray *mutColorsArray = [NSMutableArray array];
    [mutColorsArray addObject:@"red"];
    [mutColorsArray addObject:@"green"];
    [mutColorsArray addObject:@"blue"];
    [mutColorsArray addObject:@"yellow"];
    [mutColorsArray replaceObjectAtIndex:0 withObject:@"purple"];

    // Inmutable Sets
    NSSet *fruitsSet1 = [NSSet setWithObjects:@"apple", @"banana", @"orange", nil];
    NSSet *fruitsSet2 = [NSSet setWithArray:@[@"apple", @"banana", @"orange"]];

    // Mutable sets
    NSMutableSet *mutFruitsSet = [NSMutableSet setWithObjects:@"apple", @"banana", @"orange", nil];
    [mutFruitsSet addObject:@"grape"];
    [mutFruitsSet removeObject:@"apple"];

    // Dictionary
    NSDictionary *fruitColorsDictionary = @{
        @"apple" : @"red",
        @"banana" : @"yellow",
        @"orange" : @"orange",
        @"grape" : @"purple"
    };

    // In dictionaryWithObjectsAndKeys you specify the value and then the key:
    NSDictionary *fruitColorsDictionary2 = [NSDictionary dictionaryWithObjectsAndKeys:
        @"red", @"apple",
        @"yellow", @"banana",
        @"orange", @"orange",
        @"purple", @"grape",
    nil];

    // Mutable dictionary
    NSMutableDictionary *mutFruitColorsDictionary = [NSMutableDictionary dictionaryWithDictionary:fruitColorsDictionary];
    [mutFruitColorsDictionary setObject:@"green" forKey:@"apple"];
    [mutFruitColorsDictionary removeObjectForKey:@"grape"];

### Blocks

Blocks are functions that behaves as objects so they can be passed to functions or stored in arrays or dictionaries. Also, they can represent a value if they are given values so it's similar to lambdas.

    returnType (^blockName)(argumentType1, argumentType2, ...) = ^(argumentType1 param1, argumentType2 param2, ...){
        //Perform operations here
    };

    // For example

    int (^suma)(int, int) = ^(int a, int b){
        return a+b;
    };
    NSLog(@"3+4 = %d", suma(3,4));

It's also possible to define a block type to be used as a parameter in functions:

    // Define the block type
    typedef void (^callbackLogger)(void);

    // Create a bloack with the block type
    callbackLogger myLogger = ^{
        NSLog(@"%@", @"This is my block");
    };

    // Use it inside a function as a param
    void genericLogger(callbackLogger blockParam) {
        NSLog(@"%@", @"This is my function");
        blockParam();
    }
    genericLogger(myLogger);

    // Call it inline
    genericLogger(^{
        NSLog(@"%@", @"This is my second block");
    });

### Files

    // Manager to manage files
    NSFileManager *fileManager = [NSFileManager defaultManager];

    // Check if file exists:
    if ([fileManager fileExistsAtPath:@"/path/to/file.txt" ] == YES) {
        NSLog (@"File exists");
    }

    // copy files
    if ([fileManager copyItemAtPath: @"/path/to/file1.txt" toPath: @"/path/to/file2.txt" error:nil] == YES) {
        NSLog (@"Copy successful");
    }

    // Check if the content of 2 files match
    if ([fileManager contentsEqualAtPath:@"/path/to/file1.txt" andPath:@"/path/to/file2.txt"] == YES) {
        NSLog (@"File contents match");
    }

    // Delete file
    if ([fileManager removeItemAtPath:@"/path/to/file1.txt" error:nil]) {
        NSLog(@"Removed successfully");
    }

It's also possible to manage files using `NSURL` objects instead of `NSString` objects. The method names are similar, but with `URL` instead of `Path`.

> [!TIP] Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
> Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

> Support HackTricks
> - Check the subscription plans!
> - Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.
> - Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.