web-dev-qa-db-fra.com

Authentification de base avec Alamofire

Problème rencontré lors de l'authentification avec Basic Auth. J'utilise une énumération standard conforme au protocole URLRequestConvertible pour construire mes requêtes. Le problème est que lorsque je définis manuellement les en-têtes d'autorisation dans l'énumération, comme ceci:

    let user = ***
    let password = ***

    let credentialData = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding)!
    let base64Credentials = credentialData.base64EncodedStringWithOptions([])

    mutableURLRequest.setValue("Basic \(base64Credentials)", forHTTPHeaderField: "Authorization")

Je reçois toujours une réponse non autorisée 401. Cependant si je définis le mot de passe en utilisant le callback authenticate comme ceci:

    Alamofire.request(request)
        .authenticate(user: "USERNAME_HERE", password: "PASSWORD_HERE")
        .responseJSON { (response) -> Void in
            print("JSON response \(response)")
            completion(success: true, error: nil)
    }

Cela authentifie correctement. J'aimerais pouvoir le définir manuellement dans l'énumération conforme à URLRequestConvertible au lieu de transmettre les informations d'identification dans authenticate.

Je sais qu’il utilise une NSURLCredential sous le capot pour les défis d’authentification, mais j’aimerais pouvoir le régler manuellement.

Voici ma mise en œuvre URLRequestConvertible:

enum CheckedUpAPI: URLRequestConvertible {
    static let baseURLString = "https://***"
    static let APIKey = "***"
    static let APIClientName  = "iPad"


    case UpdatePatient(String, [String: AnyObject])


    var method: Alamofire.Method {
        switch self {
        case .UpdatePatient:
            return .PATCH
        }
    }

    var path: String {
        switch self {
        case .UpdatePatient(let patientID, _):
            return "patients/\(patientID)"
        }
    }

    // MARK: URLRequestConvertible

    var URLRequest: NSMutableURLRequest {
        let URL = NSURL(string: CheckedUpAPI.baseURLString)!
        let mutableURLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(path))
        mutableURLRequest.HTTPMethod = method.rawValue


/**
        We are not setting any authorization headers since they requests return 401
        the `authenticate` function on Alamofire.request does the trick

        let user = "[email protected]"
        let password = "test"

        let credentialData = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding)!
        let base64Credentials = credentialData.base64EncodedStringWithOptions([])

        mutableURLRequest.setValue("Basic \(base64Credentials)", forHTTPHeaderField: "Authorization")
*/
        mutableURLRequest.setValue(CheckedUpAPI.APIKey, forHTTPHeaderField: "API-Key")

        switch self {
        case .UpdatePatient(_, let parameters):
            return Alamofire.ParameterEncoding.JSON.encode(mutableURLRequest, parameters: parameters).0
        }
    }
}
iosswiftauthenticationalamofirensurlcredential
12
Walter Martin Vargas-Pena

En fin de compte compris quel était le problème. En fin de compte, il s'agissait d'une barre oblique de fin manquante dans l'URL. Il semble qu'Alamofire ne le gère pas de la même manière qu'AFNetworking. J'ai pu comprendre comment consigner les demandes et constater que nous perdions des octets dans la demande.

2
Walter Martin Vargas-Pena

Dans Swift 3.0

Utilisez le code suivant -

    let user = ***
    let password = ***
    let credentialData = "\(user):\(password)".data(using: String.Encoding.utf8)!
    let base64Credentials = credentialData.base64EncodedString(options: [])
    let headers = ["Authorization": "Basic \(base64Credentials)"]

    Alamofire.request(customerURL,
                      method: .get,
                      parameters: nil,
                      encoding: URLEncoding.default,
                      headers:headers)
        .validate()
        .responseJSON { response in
            if response.result.value != nil{                    
               print(response)
            }else{

            }
    }
19
be.with.veeresh

Vous pouvez essayer ce code:

    let user = ***
    let password = ***
    let credentialData = "\(user):\(password)".dataUsingEncoding(NSUTF8StringEncoding)!
    let base64Credentials = credentialData.base64EncodedStringWithOptions([])
    let headers = ["Authorization": "Basic \(base64Credentials)"]

Alamofire.manager.request(.GET, stringURL,headers: headers, parameters: params as? [String : AnyObject])
        .responseJSON { response  in
            if (response.result.error == nil){
                success(data: response.result.value)
            }else{
                fail(error: response.result.error)
            }
    }
11
Pheaktra Ty
Alamofire.request(urlString, method: .get).authenticate(user: "username", password: "pwd").responseJSON

Juste authentifier

9
Badre

Swift 4 

private func getHeaders() -> [String: String] {
        let userName = "xxxx"
        let password = "xxxx"
        let credentialData = "\(userName):\(password)".data(using: .utf8)
        guard let cred = credentialData else { return ["" : ""] }
        let base64Credentials = cred.base64EncodedData(options: [])
        guard let base64Date = Data(base64Encoded: base64Credentials) else { return ["" : ""] }
        return ["Authorization": "Basic \(base64Date.base64EncodedString())"]
    }
1
Rajesh Panda

Alamofire offre une approche encore plus simple que la création manuelle de vos propres en-têtes.

Le code correspondant de la section "Authentification de base" ici :

  manager.request(.GET, "https://api.parse.com/1/classes/Spot/")
    .authenticate(user: username, password: password)
    .responseSpotsArray { response in
      completionHandler(response.result)
    }
1
Tim VP