Swift Zeichenkette mit digitaler Signatur

Question

Ich habe Projekt, wo ich Zeichenkette (roh oder Base64 codiert) mit privater digitaler Signatur (das Passwort hat). Ich suchte im Internet und stellte fest, dass das private digitale Zertifikat das x.509-Format (RSA) ist. In xcode habe ich UIFileSharingEnabled auf Enabled gesetzt und dieses rsa.p12-Zertifikat mit Itunes hochgeladen. Als nächstes bekomme ich das Zertifikat aus dem Dokumentenverzeichnis im (Daten- oder String-) Format. Meine Frage ist, wie kann ich irgendeinen Text mit digitaler Signatur verschlüsseln? Ich habe versucht, diese Lib https://github.com/TakeScoop/SwiftyRSA/issues zu verwenden, aber diese Bibliothek unterstützt kein X.509-Zertifikat.

Answer 1

Ich fand nur den Code, die Zeichenfolge Text codiert und es funktioniert

func signRequestorId(requestorID: String) -> String? { 

    let name = "RSA256_4f1826090c554a439c419043270d40f7d.p12" 
    guard let certificateData = CustomFileManager.getFile(by: name) else { 
     return nil 
    } 

    var status: OSStatus 

    let certificateKey = "123456" 
    let options = [kSecImportExportPassphrase as String : certificateKey] 

    var optItems: CFArray? 
    status = SecPKCS12Import(certificateData as CFData, options as CFDictionary, &optItems) 
    if status != errSecSuccess { 
     print("Cannot sign the device id info: failed importing keystore.") 
     return nil 
    } 
    guard let items = optItems else { 
     return nil 
    } 

    // Cast CFArrayRef to Swift Array 
    let itemsArray = items as [AnyObject] 
    // Cast CFDictionaryRef as Swift Dictionary 
    guard let myIdentityAndTrust = itemsArray.first as? [String : AnyObject] else { 
     return nil 
    } 

    // Get our SecIdentityRef from the PKCS #12 blob 
    let outIdentity = myIdentityAndTrust[kSecImportItemIdentity as String] as! SecIdentity 
    var myReturnedCertificate: SecCertificate? 
    status = SecIdentityCopyCertificate(outIdentity, &myReturnedCertificate) 
    if status != errSecSuccess { 
     print("Failed to retrieve the certificate associated with the requested identity.") 
     return nil 
    } 

    // Get the private key associated with our identity 
    var optPrivateKey: SecKey? 
    status = SecIdentityCopyPrivateKey(outIdentity, &optPrivateKey) 
    if status != errSecSuccess { 
     print("Failed to extract the private key from the keystore.") 
     return nil 
    } 
    // Unwrap privateKey from optional SecKeyRef 
    guard let privateKey = optPrivateKey else { 
     return nil 
    } 

    // Retrieve the digital signature and sign the requestor 

    // Get the maximum size of the digital signature 
    var signedBytesSize: size_t = SecKeyGetBlockSize(privateKey) 
    var signedBytes: UnsafeMutablePointer<UInt8> 

    // alloc a buffer to hold the signature 
    signedBytes = UnsafeMutablePointer<UInt8>.allocate(capacity: signedBytesSize) 
    memset(signedBytes, 0x0, signedBytesSize) 
    // We're calling alloc here, so we need to destroy and deinit 
    defer { 
     signedBytes.deinitialize() 
     signedBytes.deallocate(capacity: signedBytesSize) 
    } 

    // Sign data 
    let requestorData = requestorID.data(using: String.Encoding.utf8)! 
    // Generate a digital signature for our requestor from our cert 
    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: requestorData.count) 
    let stream = OutputStream(toBuffer: buffer, capacity: requestorData.count) 

    stream.open() 
    requestorData.withUnsafeBytes({ (p: UnsafePointer<UInt8>) -> Void in 
     stream.write(p, maxLength: requestorData.count) 
    }) 

    stream.close() 

    let weidformat = UnsafePointer<UInt8>(buffer) 

    status = SecKeyRawSign(privateKey, .PKCS1, weidformat, 
          requestorData.count, signedBytes, &signedBytesSize) 

    if status != errSecSuccess { 
     print("Cannot sign the device id info: failed obtaining the signed bytes.") 
     return nil 
    } 

    let encryptedBytes = NSData(bytes: signedBytes, length: signedBytesSize) 
    let signedRequestorId = encryptedBytes.base64EncodedString(options: []) 

    print(signedRequestorId) 
    return signedRequestorId 
} 

U brauchen Funktion auch Dokument mit Namen kennen

static func getFile(by name: String)-> Data?{ 
    let documentsUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first 
    let destinationUrl = documentsUrl!.appendingPathComponent("\(name)") 

    let isFileFound = FileManager.default.fileExists(atPath: destinationUrl.path) 
    if isFileFound { 
     let documentContent = FileManager.default.contents(atPath: destinationUrl.path) 
     return documentContent 
    } 
    return nil 
} 
enter code here