Can't get HTTP basic Auth working

Question

I'm trying to call a local Rest Service that uses HTTP Basic Auth.

As a result of my request I get the following:

Found: error - unauthorized
Found: reason - password required

Here is my function that is doing the request.

func connect(url: String) -> Bool {

    let url: NSURL = NSURL(string: url);
    let login:String = "admin";
    let password:String = "test123";

    var defaultCredentials: NSURLCredential = NSURLCredential(user: login, password: password, persistence: NSURLCredentialPersistence.ForSession);

    let host: String = url.host;
    let port: Int = url.port;
    let prot: String = url.scheme;

    println("set following vars \(host) + \(port) + \(prot)");

    var protectionSpace: NSURLProtectionSpace = NSURLProtectionSpace(host: host,port: port,`protocol`: prot,realm: nil,authenticationMethod: NSURLAuthenticationMethodHTTPBasic);

    var credentialStorage: NSURLCredentialStorage = NSURLCredentialStorage.sharedCredentialStorage();
    credentialStorage.setCredential(defaultCredentials, forProtectionSpace: protectionSpace);

    var sessionConfiguration: NSURLSessionConfiguration = NSURLSessionConfiguration.defaultSessionConfiguration();
    sessionConfiguration.URLCredentialStorage = credentialStorage;

    let session: NSURLSession = NSURLSession(configuration: sessionConfiguration); //NSURLSession.sharedSession()


    //NSURLSession.sessionWithConfiguration(sessionConfiguration);

    let task = session.dataTaskWithURL(url, completionHandler: {data, response, error -> Void in
        println("Task completed")
        if((error) != nil) {
            // If there is an error in the web request, print it to the console
            println(error.localizedDescription)
        }
        var err: NSError?
        var jsonResult = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.MutableContainers, error: &err) as NSDictionary
        if(err != nil) {
            // If there is an error parsing JSON, print it to the console
            println("JSON Error \(err!.localizedDescription)")
        }


        self.delegate.didReceiveAPIResults(jsonResult);

    })
    task.resume()

    return true
}

Could anybody please give me a hint?

Answer 1

I would consider using AFNetworking. I tried using AlamoFire but ran into an issue with Basic Auth (more info on that here). This is what I used to do Basic Auth in Swift.

    static let sharedInstance = NetworkManager(url: NSURL(string: baseUrl))
    ...
    sharedInstance.requestSerializer.clearAuthorizationHeader()
    sharedInstance.requestSerializer.setAuthorizationHeaderFieldWithUsername(email, password:password)
    sharedInstance.POST(loginAPI,
        parameters: nil,
        success: success,
        failure: failure)

Note that success and failure are closures (like blocks if you are coming from Objective C) that I am passing into my method.

If you haven't imported an Objective C library into Swift yet, I would recommend using cocoapods as you usually would. Then simply add this line to your Bridging-Header.h file.

#import <AFNetworking/AFNetworking.h>

Answer 2

I'm using Alamofire 3 and greater. To pass headers to the Webservice. I place the headers, as you can see below, as the "headers:" param

Alamofire.request(
            .POST,
            "https://mysuperurl.com/path",
            parameters:nil,
            encoding: .URL,
            headers:["Authorization": "Basic " + base64String!])
            .validate()
            .responseJSON { response in
                switch response.result {
                case .Success: 
                    print("Validation Successful")
                case .Failure(let error):
                    print(error)
                }
        }

Answer 3

SWIFT 2.0 +

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


//        let manager = Alamofire.Manager.sharedInstance

        Alamofire.Manager.sharedInstance.session.configuration.timeoutIntervalForRequest = 300

        Alamofire.Manager.sharedInstance.upload(.POST,url,headers : headers,multipartFormData: { multipartFormData in
            NSLog("url----- %@ \n perameter --- %@",url, dicsParams)
            for (key, value) in dicsParams {
            },
            encodingCompletion: { encodingResult in
                switch encodingResult {
                case .Success(let upload, _, _):
                    upload.responseJSON { response in
                        debugPrint(response)
                        AppHelper.hideLoadingSpinner()
                        if response.result.value is NSNull
                        {
                        }
                        else
                        {
                            if let JSON = response.result.value {
                                var mydict = NSMutableDictionary()
                                mydict = JSON as! NSMutableDictionary

                                if (self.delegate != nil){
                                    print("response:--------------------\n %@",mydict)

                                }
                            }
                            else
                            {
                                print("response not converted to JSON")
                            }

                        }
                    }
                case .Failure(let encodingError):
                    print(encodingError)
                    if (self.delegate != nil){
                        self.delegate.HttpWrapperfetchDataFail!(self, error: encodingError as NSError);
                    }
                }
            }
        )

Answer 4

This is the rudimentary way (from here: https://stackoverflow.com/a/24380884) but works:

// set up the base64-encoded credentials
let username = "user"
let password = "pass"
let loginString = NSString(format: "%@:%@", username, password)
let loginData: NSData = loginString.dataUsingEncoding(NSUTF8StringEncoding)
let base64LoginString = loginData.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.fromMask(0))

// create the request
let url = NSURL(string: "http://www.example.com/")
let request = NSMutableURLRequest(URL: url)
request.HTTPMethod = "POST"
request.setValue("Basic \(base64LoginString)", forHTTPHeaderField: "Authorization")

// fire off the request
// make sure your class conforms to NSURLConnectionDelegate
let urlConnection = NSURLConnection(request: request, delegate: self)

A better way, if you receive an authentication challenge, is explained here:

https://stackoverflow.com/a/24975120