HTTPS

From Rosetta Code
Revision as of 18:45, 17 August 2011 by rosettacode>Markhobley ({{omit from|Openscad}})
Task
HTTPS
You are encouraged to solve this task according to the task description, using any language you may know.

Print an HTTPS URL's content to the console. Checking the host certificate for validity is recommended. The client should not authenticate itself to the server — the webpage https://sourceforge.net/ supports that access policy — as that is the subject of other tasks.

Readers may wish to contrast with the HTTP Request task, and also the task on HTTPS request with authentication.

AutoHotkey

Library: wininet

<lang AutoHotkey>URL  := "https://sourceforge.net/" WININET_Init() msgbox % html := UrlGetContents(URL) WININET_UnInit() return

  1. include urlgetcontents.ahk
  2. include wininet.ahk</lang>

C

Library: libcurl

<lang c>#include <stdio.h>

  1. include <stdlib.h>
  2. include <curl/curl.h>

int main(void) { 

       CURL *curl;
       char buffer[CURL_ERROR_SIZE];

       if ((curl = curl_easy_init()) != NULL) {
               curl_easy_setopt(curl, CURLOPT_URL, "https://sourceforge.net/");
               curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
               curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, buffer);
               if (curl_easy_perform(curl) != CURLE_OK) {
                       fprintf(stderr, "%s\n", buffer);
                       return EXIT_FAILURE;
               }
               curl_easy_cleanup(curl);
       }
       return EXIT_SUCCESS;

}</lang>

C#

Works with: C sharp version 3.0

<lang csharp>using System; using System.Net;

class Program { 

   static void Main(string[] args)
   {
       var client = new WebClient();
       var data = client.DownloadString("https://www.google.com");

       Console.WriteLine(data);
   }

}</lang>

Clojure

Using the duck-streams as a convenient wrapper for Java's networking classes, grabbing the contents of an HTTPS URL is as easy as:

<lang clojure>(use '[clojure.contrib.duck-streams :only (slurp*)]) (print (slurp* "https://sourceforge.net"))</lang>

The usual Java mechanisms can be used to manage acceptance of SSL certificates if required.

Works with: Clojure version 1.2

<lang clojure>(print (slurp "https://sourceforge.net"))</lang>

Common Lisp

Library: DRAKMA

First grabbing the entire body as a string, and then by pulling from a stream. This is the same code as in HTTP Request; drakma:http-request supports SSL.

<lang lisp>(defun wget-drakma-string (url &optional (out *standard-output*)) 

 "Grab the body as a string, and write it to out."
 (write-string (drakma:http-request url) out))

(defun wget-drakma-stream (url &optional (out *standard-output*)) 

 "Grab the body as a stream, and write it to out."
 (loop with body = (drakma:http-request url :want-stream t)
       for line = (read-line body nil nil)
       while line do (write-line line)
       finally (close body)))
Use

(wget-drakma-stream "https://sourceforge.net")</lang>

Delphi

<lang Delphi>program ShowHTTPS;

{$APPTYPE CONSOLE}

uses IdHttp, IdSSLOpenSSL;

var 

 s: string;
 lHTTP: TIdHTTP;
 lIOHandler: TIdSSLIOHandlerSocketOpenSSL;

begin 

 lHTTP := TIdHTTP.Create(nil);
 lIOHandler := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
 try
   lHTTP.IOHandler := lIOHandler;
   lHTTP.HandleRedirects := True;
   s := lHTTP.Get('https://sourceforge.net/');
   Writeln(s);
 finally
   lHTTP.Free;
   lIOHandler.Free;
 end;

end.</lang>

Erlang

Synchronous

<lang erlang>-module(main). -export([main/1]).

main([Url|[]]) -> 

  inets:start(),
  ssl:start(),
  case http:request(get, {URL, []}, [{ssl,[{verify,0}]}], []) of
      {ok, {_V, _H, Body}} -> io:fwrite("~p~n",[Body]);
      {error, Res} -> io:fwrite("~p~n", [Res])
  end.</lang>

Asynchronous

<lang erlang>-module(main). -export([main/1]).

main([Url|[]]) -> 

  inets:start(),
  ssl:start(),
  http:request(get, {Url, [] }, [{ssl,[{verify,0}]}], [{sync, false}]),
  receive
      {http, {_ReqId, Res}} -> io:fwrite("~p~n",[Res]);
      _Any -> io:fwrite("Error: ~p~n",[_Any])
      after 10000 -> io:fwrite("Timed out.~n",[])
  end.</lang>

Using it <lang erlang>|escript ./req.erl https://sourceforge.net/</lang>

F#

The underlying .NET classes handle secure web connections the same way they manage insecure connections. <lang fsharp>#light let wget (url : string) = 

   let c = new System.Net.WebClient()
   c.DownloadString(url)</lang>

Groovy

<lang groovy>new URL("https://sourceforge.net").eachLine { println it }</lang>

Ioke

Translation of: Java

<lang ioke>connection = URL new("https://sourceforge.net") openConnection scanner = Scanner new(connection getInputStream)

while(scanner hasNext, 

 scanner next println

)</lang>

J

Using gethttp from Web Scraping

<lang j> #page=: gethttp'https://sourceforge.net' 0 

  #page=: '--no-check-certificate' gethttp'https://sourceforge.net'

900</lang>

(We can not load the example page using https unless we disable certificate checking. The numbers are the number of characters retrieved.)

Java

Additional certificate information is available through the javax.net.ssl.HttpsURLConnection interface. <lang Java>URL url = new URL("https://sourceforge.net"); HttpsURLConnection connection = (HttpsURLConnection) url.openConnection(); Scanner scanner = new Scanner(connection.getInputStream());

while (scanner.hasNext()) { 

   System.out.println(scanner.next());

}</lang>

Mathematica

Straight forward "Import" task. More complicated secure web access can bee done using J/Link; essentially a link to Java API. <lang Mathematica>content=Import["https://sourceforge.net", "HTML"]</lang>


Perl

Library: LWP

<lang perl>use strict; use LWP::UserAgent;

my $url = 'https://www.rosettacode.org'; my $response = LWP::UserAgent->new->get( $url );

$response->is_success or die "Failed to GET '$url': ", $response->status_line;

print $response->as_string;</lang>

PHP

<lang php>echo file_get_contents('https://sourceforge.net');</lang>

PicoLisp

PicoLisp has no functionality for communicating with a HTTPS server (only for the other direction), but it is easy to use an external tool <lang PicoLisp>(in '(curl "https://sourceforge.net") # Open a pipe to 'curl' 

  (out NIL (echo)) )                  # Echo to standard output</lang>

PowerShell

<lang powershell>$wc = New-Object Net.WebClient $wc.DownloadString('https://sourceforge.net')</lang> If the certificate could not be validated (untrusted, self-signed, expired), then an Exception is thrown with the message “The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel.” so certificate validation is done automatically by the method.

Python

Python's urllib.request library, (urllib2 in Python2.x) has support for SSL if the interpreter's underlying httplib libraries were compiled with SSL support. By default this will be the enabled for default Python installations on most platforms.

Python 3.x: <lang Python> from urllib.request import urlopen print(urlopen('https://sourceforge.net/').read())</lang>

(Python 2.x) <lang Python> from urllib2 import urlopen print urlopen('https://sourceforge.net/').read()</lang>

R

Library: RCurl
Library: XML

The basic idea is to use getURL (as with HTTP_Request), but with some extra parameters. <lang R>library(RCurl) webpage <- getURL("https://sourceforge.net/", .opts=list(followlocation=TRUE, ssl.verifyhost=FALSE, ssl.verifypeer=FALSE))</lang> In this case, the webpage output contains unprocessed characters, e.g. \" instead of " and \\ instead of \, so we need to process the markup. <lang R>wp <- readLines(tc <- textConnection(webpage)) close(tc)</lang> Finally, we parse the HTML and find the interesting bit. <lang R>pagetree <- htmlTreeParse(wp) pagetree$children$html</lang>


REALbasic

REALBasic provides an HTTPSecureSocket class for handling HTTPS connections. The 'Get' method of the HTTPSecureSocket class does not return any data (it can write data out to a file, but I chose not to take that route.) So, this example instead uses a subclass of the HTTPSecureSocket class which adds the necessary functionality to allow us to merely call a method of the HTTPSecureSocket which accepts a URL and returns a string containing the retrieved data. (There is undoubtedly a cleaner, nicer way to do this.) Note that in this example I declare classes in code (using Class/End Class,) whereas in real life classes are declared using the IDE. <lang REALbasic> Class App As ConsoleApplication 

   Function Run(args() as String) As Integer
     Dim sock As New secureSock  //Subclassed from the HTTPSecureSocket class
     Stdout.Write(sock.Getter("https://sourceforge.net"))
   End Function

End Class

Class secureSock As HTTPSecureSocket 

   Private pageData As String

   Sub PageReceived(url as string, httpStatus as integer, headers as internetHeaders, content as string)
     pageData = content
   End Sub

   Function getter(URL As String) As String
     me.Get(URL)
     Return pageData
   End Function

End Class </lang>


RLaB

See [[1]]

Ruby

This solution doesn't use the open-uri convenience package that the HTTP Request#Ruby solution uses: the Net::HTTP object must be told to use SSL before the session is started. <lang ruby>require 'net/https' require 'uri' require 'pp'

uri = URI.parse('https://sourceforge.net') http = Net::HTTP.new(uri.host,uri.port) http.use_ssl = true http.verify_mode = OpenSSL::SSL::VERIFY_NONE

http.start do 

 content = http.get("/")
 p [content.code, content.message]
 pp content.to_hash
 puts content.body

end</lang>

outputs 

["302", "Found"]
{"location"=>["http://sourceforge.net/"],
 "content-type"=>["text/html; charset=UTF-8"],
 "connection"=>["close"],
 "server"=>["nginx/0.7.60"],
 "date"=>["Sun, 30 Aug 2009 20:20:07 GMT"],
 "content-length"=>["229"],
 "set-cookie"=>
  ["sf.consume=89f65c6fadd222338b2f3de6f8e8a17b2c8f67c2gAJ9cQEoVQhfZXhwaXJlc3ECY2RhdGV0aW1lCmRhdGV0aW1lCnEDVQoH9gETAw4HAAAAhVJxBFUDX2lkcQVVIDEyOWI2MmVkOWMwMWYxYWZiYzE5Y2JhYzcwZDMxYTE4cQZVDl9hY2Nlc3NlZF90aW1lcQdHQdKmt73UN21VDl9jcmVhdGlvbl90aW1lcQhHQdKmt73UN2V1Lg==; expires=Tue, 19-Jan-2038 03:14:07 GMT; Path=/"]}
<html>
 <head>
  <title>302 Found</title>
 </head>
 <body>
  <h1>302 Found</h1>
  The resource was found at <a href="http://sourceforge.net/">http://sourceforge.net/</a>;
you should be redirected automatically.


 </body>
</html>

Tcl

Though Tcl's built-in http package does not understand SSL, it does support the registration of external handlers to accommodate additional protocols. This allows the use of the Tls package to supply the missing functionality with only a single line to complete the registration. <lang tcl>package require http package require tls

  1. Tell the http package what to do with “https:” URLs.
  3. First argument is the protocol name, second the default port, and
  4. third the connection builder command

http::register "https" 443 ::tls::socket

  1. Make a secure connection, which is almost identical to normal
  2. connections except for the different protocol in the URL.

set token [http::geturl "https://sourceforge.net/"]

  1. Now as for conventional use of the “http” package

puts [http::data $token] http::cleanup $token</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT SET DATEN = REQUEST ("https://sourceforge.net")

  • {daten}

</lang>

Retrieved from "https://rosettacode.org/wiki/HTTPS?oldid=112759"