[AltStore] Uses GrandSlam Authentication

Retrieves anisette data from AltServer so we can authenticate with GSA.

AltKit/NSError+ALTServerError.h

@@ -27,6 +27,12 @@ typedef NS_ERROR_ENUM(AltServerErrorDomain, ALTServerError)
     ALTServerErrorInstallationFailed = 8,
     ALTServerErrorMaximumFreeAppLimitReached = 9,
     ALTServerErrorUnsupportediOSVersion = 10,
+    
+    ALTServerErrorUnknownRequest = 11,
+    ALTServerErrorUnknownResponse = 12,
+    
+    ALTServerErrorInvalidAnisetteData = 13,
+    ALTServerErrorPluginNotFound = 14
 };
 
 NS_ASSUME_NONNULL_BEGIN

AltKit/NSError+ALTServerError.m

@@ -61,6 +61,18 @@ NSErrorDomain const AltServerInstallationErrorDomain = @"com.rileytestut.AltServ
             
         case ALTServerErrorUnsupportediOSVersion:
             return NSLocalizedString(@"Your device must be running iOS 12.2 or later to install AltStore.", @"");
+            
+        case ALTServerErrorUnknownRequest:
+            return NSLocalizedString(@"AltServer does not support this request.", @"");
+            
+        case ALTServerErrorUnknownResponse:
+            return NSLocalizedString(@"Received an unknown response from AltServer.", @"");
+            
+        case ALTServerErrorInvalidAnisetteData:
+            return NSLocalizedString(@"Invalid anisette data.", @"");
+            
+        case ALTServerErrorPluginNotFound:
+            return NSLocalizedString(@"Could not connect to Mail plug-in. Please make sure the plug-in is installed and Mail is running, then try again.", @"");
     }
 }
     

AltKit/ServerProtocol.swift

@@ -7,22 +7,201 @@
 //
 
 import Foundation
+import AltSign
 
 public let ALTServerServiceType = "_altserver._tcp"
 
 // Can only automatically conform ALTServerError.Code to Codable, not ALTServerError itself
 extension ALTServerError.Code: Codable {}
 
-protocol ServerMessage: Codable
+protocol ServerMessageProtocol: Codable
 {
     var version: Int { get }
     var identifier: String { get }
 }
 
-public struct PrepareAppRequest: ServerMessage
+public enum ServerRequest: Decodable
+{
+    case anisetteData(AnisetteDataRequest)
+    case prepareApp(PrepareAppRequest)
+    case beginInstallation(BeginInstallationRequest)
+    case unknown(identifier: String, version: Int)
+    
+    var identifier: String {
+        switch self
+        {
+        case .anisetteData(let request): return request.identifier
+        case .prepareApp(let request): return request.identifier
+        case .beginInstallation(let request): return request.identifier
+        case .unknown(let identifier, _): return identifier
+        }
+    }
+    
+    var version: Int {
+        switch self
+        {
+        case .anisetteData(let request): return request.version
+        case .prepareApp(let request): return request.version
+        case .beginInstallation(let request): return request.version
+        case .unknown(_, let version): return version
+        }
+    }
+    
+    private enum CodingKeys: String, CodingKey
+    {
+        case identifier
+        case version
+    }
+    
+    public init(from decoder: Decoder) throws
+    {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        
+        let version = try container.decode(Int.self, forKey: .version)
+        
+        let identifier = try container.decode(String.self, forKey: .identifier)
+        switch identifier
+        {
+        case "AnisetteDataRequest":
+            let request = try AnisetteDataRequest(from: decoder)
+            self = .anisetteData(request)
+            
+        case "PrepareAppRequest":
+            let request = try PrepareAppRequest(from: decoder)
+            self = .prepareApp(request)
+            
+        case "BeginInstallationRequest":
+            let request = try BeginInstallationRequest(from: decoder)
+            self = .beginInstallation(request)
+            
+        default:
+            self = .unknown(identifier: identifier, version: version)
+        }
+    }
+}
+
+public enum ServerResponse: Decodable
+{
+    case anisetteData(AnisetteDataResponse)
+    case installationProgress(InstallationProgressResponse)
+    case error(ErrorResponse)
+    case unknown(identifier: String, version: Int)
+    
+    var identifier: String {
+        switch self
+        {
+        case .anisetteData(let response): return response.identifier
+        case .installationProgress(let response): return response.identifier
+        case .error(let response): return response.identifier
+        case .unknown(let identifier, _): return identifier
+        }
+    }
+    
+    var version: Int {
+        switch self
+        {
+        case .anisetteData(let response): return response.version
+        case .installationProgress(let response): return response.version
+        case .error(let response): return response.version
+        case .unknown(_, let version): return version
+        }
+    }
+    
+    private enum CodingKeys: String, CodingKey
+    {
+        case identifier
+        case version
+    }
+    
+    public init(from decoder: Decoder) throws
+    {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        
+        let version = try container.decode(Int.self, forKey: .version)
+        
+        let identifier = try container.decode(String.self, forKey: .identifier)
+        switch identifier
+        {
+        case "AnisetteDataResponse":
+            let response = try AnisetteDataResponse(from: decoder)
+            self = .anisetteData(response)
+            
+        case "InstallationProgressResponse":
+            let response = try InstallationProgressResponse(from: decoder)
+            self = .installationProgress(response)
+            
+        case "ErrorResponse":
+            let response = try ErrorResponse(from: decoder)
+            self = .error(response)
+            
+        default:
+            self = .unknown(identifier: identifier, version: version)
+        }
+    }
+}
+
+public struct AnisetteDataRequest: ServerMessageProtocol
 {
     public var version = 1
-    public var identifier = "PrepareApp"
+    public var identifier = "AnisetteDataRequest"
+    
+    public init()
+    {
+    }
+}
+
+public struct AnisetteDataResponse: ServerMessageProtocol
+{
+    public var version = 1
+    public var identifier = "AnisetteDataResponse"
+    
+    public var anisetteData: ALTAnisetteData
+    
+    private enum CodingKeys: String, CodingKey
+    {
+        case identifier
+        case version
+        case anisetteData
+    }
+
+    public init(anisetteData: ALTAnisetteData)
+    {
+        self.anisetteData = anisetteData
+    }
+    
+    public init(from decoder: Decoder) throws
+    {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.version = try container.decode(Int.self, forKey: .version)
+        self.identifier = try container.decode(String.self, forKey: .identifier)
+        
+        let json = try container.decode([String: String].self, forKey: .anisetteData)
+        
+        if let anisetteData = ALTAnisetteData(json: json)
+        {
+            self.anisetteData = anisetteData
+        }
+        else
+        {
+            throw DecodingError.dataCorruptedError(forKey: CodingKeys.anisetteData, in: container, debugDescription: "Couuld not parse anisette data from JSON")
+        }
+    }
+    
+    public func encode(to encoder: Encoder) throws
+    {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.version, forKey: .version)
+        try container.encode(self.identifier, forKey: .identifier)
+        
+        let json = self.anisetteData.json()
+        try container.encode(json, forKey: .anisetteData)
+    }
+}
+
+public struct PrepareAppRequest: ServerMessageProtocol
+{
+    public var version = 1
+    public var identifier = "PrepareAppRequest"
     
     public var udid: String
     public var contentSize: Int
@@ -34,37 +213,41 @@ public struct PrepareAppRequest: ServerMessage
     }
 }
 
-public struct BeginInstallationRequest: ServerMessage
+public struct BeginInstallationRequest: ServerMessageProtocol
 {
     public var version = 1
-    public var identifier = "BeginInstallation"
+    public var identifier = "BeginInstallationRequest"
     
     public init()
     {
     }
 }
 
-public struct ServerResponse: ServerMessage
+public struct ErrorResponse: ServerMessageProtocol
 {
     public var version = 1
-    public var identifier = "ServerResponse"
+    public var identifier = "ErrorResponse"
+    
+    public var error: ALTServerError {
+        return ALTServerError(self.errorCode)
+    }
+    private var errorCode: ALTServerError.Code
+    
+    public init(error: ALTServerError)
+    {
+        self.errorCode = error.code
+    }
+}
+
+public struct InstallationProgressResponse: ServerMessageProtocol
+{
+    public var version = 1
+    public var identifier = "InstallationProgressResponse"
     
     public var progress: Double
     
-    public var error: ALTServerError? {
-        get {
-            guard let code = self.errorCode else { return nil }
-            return ALTServerError(code)
-        }
-        set {
-            self.errorCode = newValue?.code
-        }
-    }
-    private var errorCode: ALTServerError.Code?
-    
-    public init(progress: Double, error: ALTServerError?)
+    public init(progress: Double)
     {
         self.progress = progress
-        self.error = error
     }
 }