mIRC script for GPG authentication (version 1.1b)

/**
 * @file
 * @author Joric <irc.freenode.net/#bitcoin-otc>
 * @version 1.1b
 *
 * @section LICENSE
 *
 * This program is in the public domain
 *
 * @section DESCRIPTION
 *
 * GPG authentication helper script for mIRC
 * Usage: /gpgauth [passphrase]
 *
 * You can install this script by typing /load -rs <path-to-script>
 * You can uninstall this script by typing /unload -rs <path-to-script>
 * You can also just copy/paste it into 'remote' window and then hit the OK button.
 *
 * Use /reload -rs <path-to-script> to reload script after editing.
 */

/**
 * menu
 *
 * adds options to the global menu
 * you may edit or comment them out and reload script to accept changes
 */

menu status,channel,query {
    GPG Options: gpg_options
    $iif(%gpg.debug,GPG Reload,$null): reload -rs $script
;    GPG Evaluate: gpg_autorun
}

alias gpg_authenticate {
    join #bitcoin-otc-foyer
    gpgauth %gpg.passphrase
}

alias gpg_autorun {
    var %i = 1
    var %n = $numtok(%gpg.sequence, $asc(|))
    while (%i <= %n) {
        $gettok(%gpg.sequence, %i, $asc(|))
        inc %i
    }
}

alias gpg_load {
    set %gpg.ini $scriptdir $+ gpgauth.ini
    set %gpg.executable $readini(%gpg.ini, config, gpg.executable)
    set %gpg.passphrase $readini(%gpg.ini, config, gpg.passphrase)
    set %gpg.sequence $readini(%gpg.ini, config, gpg.sequence)
    set %gpg.autostart $readini(%gpg.ini, config, gpg.autostart)
    set %gpg.hideoptions $readini(%gpg.ini, config, gpg.hideoptions)

    if (!%gpg.executable) {
        set %gpg.executable C:\Program Files\GNU\GnuPG\gpg.exe
    }
}

alias writeiniex {
    if ($4) {
        writeini $1 $2 $3 $4-
    }
    else {
        remini $1 $2 $3
    }
}

alias gpg_save {
    set %gpg.ini $scriptdir $+ gpgauth.ini
    writeiniex %gpg.ini config gpg.executable %gpg.executable
    writeiniex %gpg.ini config gpg.passphrase %gpg.passphrase
    writeiniex %gpg.ini config gpg.sequence %gpg.sequence
    writeiniex %gpg.ini config gpg.hideoptions %gpg.hideoptions
    writeiniex %gpg.ini config gpg.autostart %gpg.autostart
}

alias gpg_options {
    dialog -m gpg_options gpg_options
}

/**
 * gpgauth
 *
 * Automated gpg authentication for #bitcoin-otc
 *
 * @param passphrase
 */

alias gpgauth {
    gpg_load
    set %gpg.passphrase $1
    msg gribble ;;gpg eauth $me
}

on *:TEXT:*:?: {
    if ($nick != gribble) {
        return
    }
    else if ($regex($1-,/get your encrypted otp from (http:[^ ]+)/i)) {
        var %url = $regml(1)
        wget %url %gpg.passphrase
        notice $me downloading %url
    }
    else if ($regex($1-,/You are now authenticated/i)) {
        notice $me authenticated
        msg gribble ;;letmein
        ;closemsg gribble
        .timer0 1 2 join #bitcoin-otc
    }
    else if ($regex($1-,/you must be present/i)) {
        notice $me you have to join a channel first
    }
    else if ($regex($1-,/incorrect one-time password/i)) {
        notice $me incorrect password
    }
}

alias gpg_quote {
    return $chr(34) $+ $1 $+ $chr(34)
}

alias wget_callback {
    notice $me decrypting message...

    var %key = $gpg_quote($scriptdir $+ $1)
    var %out = $gpg_quote($scriptdir $+ stdout.txt)
    var %err = $gpg_quote($scriptdir $+ stderr.txt)
    var %exe = $gpg_quote(%gpg.executable)

    if (%gpg.passphrase) {
        var %cmd = echo %gpg.passphrase $+ $chr($asc(|)) %exe --decrypt --quiet --batch --passphrase-fd 0 %key 1> %out 2> %err
    }
    else {
        var %cmd = %exe --decrypt --quiet --batch %key 1> %out 2> %err
    }

    run -np cmd /C %cmd

    .timer1 1 2 /gpg_everify %out %err

    ;echo %cmd
}

alias gpg_everify {
    var %challenge = $read($1,1)
    if (%challenge) {
        msg gribble ;;gpg everify %challenge
        return
    }
    var %errmsg = $read($2,1)
    if (%errmsg) {
        notice $me %errmsg
    }
}

/**
 * wget
 *
 * Simple function for downloading files via HTTP
 * When finished, calls wget_callback <filename>
 *
 * @param url
 */

alias wget {
    if ($regex($1,/http:/\/([^/]+)([^ ]+)/g)) {
        %host = $regml(1)
        %path = $regml(2)
        var %socket $+(wget,:,$nopath(%path))
        if (!$sock(%socket)) {
          sockopen %socket %host 80
          sockmark %socket HEAD %host %path
        }
        else {
            echo $color(info) -s * Socket already in use.
        }
    }
}

on *:SOCKOPEN:wget*:{
    hadd -m ticks $sockname $ticks
    var %file = $nopath($gettok($sock($sockname).mark,3,32))
    var %fullfile = $+(",$scriptdir,%file,")
    var %sckr = sockwrite -n $sockname, %^ = $gettok($sock($sockname).mark,3,32)
    write -c %fullfile
    %sckr GET $iif(left(%^,1) != $chr(47),$chr(47) $+ %^,%^) HTTP/1.0
    %sckr HOST: $gettok($sock($sockname).mark,2,32)
    %sckr ACCEPT: *.*
    %sckr $crlf
}

on *:SOCKREAD:wget*:{
    if ($sockerr) {
        echo $color(info) -s * Error: $sock($sockname).wsmsg
        return
    }
     var %a
    :begin
    if ($gettok($sock($sockname).mark,1,32) == head) {
        sockread %a
    }
    else {
        sockread &b
    }
    if ($sockbr) {
        tokenize 32 $sock($sockname).mark
        if ($1 == HEAD) {
            if (%a) {
                ;Catching the file size, avoiding the data header
                if ($gettok(%a,1,32) == Content-Length:) { var %totsize = $gettok(%a,2,32) }
            }
            else {
                ;When there are no vars, we now we have to start binary downloading
                sockmark $sockname GET $2- %totsize
            }
        }
        elseif ($1 == GET) {
            ;Downloading ...
            var %file = $+(",$scriptdir,$nopath($3),"), %cursize = $file(%file).size
            var %totsize = $gettok($sock($sockname).mark,4,32)
            bwrite %file -1 &b
        }
      goto begin
    }
}

on *:SOCKCLOSE:wget*:{
    var %filename = $nopath($gettok($sock($sockname).mark,3,32))
    wget_callback %filename
}

/**
 * GUI implementation
 */

alias gpg_dialog_changed {
    did -e $1 3
}

on 1:dialog:gpg_options:sclick:1: {
    ;close dialog
    dialog -x $dname
    gpg_authenticate
}

on 1:dialog:gpg_options:sclick:10: {
    ;open file dialog
    var %file = $sfile($nofile(%gpg.executable) $+ *.exe)
    if (%file) {
        did -ra $dname 6 %file
        gpg_dialog_changed $dname
    }
}

on 1:dialog:gpg_options:init:0: {
    gpg_dialog_load $dname
}

alias gpg_dialog_load {
    did -ra $dname 6 %gpg.executable
    did -ra $dname 7 %gpg.passphrase
;    did -ra $dname 13 %gpg.sequence
    did $iif(%gpg.autostart, -c, -u) $dname 8
    did $iif(%gpg.hideoptions, -c, -u) $dname 9
    did -b $dname 3 ;disable apply button

    ;did -ra $dname 13 $me
    ;did -c $dname 13 1
}

alias gpg_dialog_save {
    set %gpg.executable $did($1,6)
    set %gpg.passphrase $did($1,7)
;    set %gpg.sequence $did($1,13)
    set %gpg.autostart $iif($did($1,8).state, 1, $null)
    set %gpg.hideoptions $iif($did($1,9).state, 1, $null)
    gpg_save
}

on 1:dialog:gpg_options:sclick:3: {
    ;apply button clicked
    gpg_dialog_save $dname
    did -b $dname $did
}

on 1:dialog:gpg_options:edit,sclick:6,7,8,9: {
    gpg_dialog_changed $dname
}

on 1:dialog:gpg_options:sclick:2: {
    gpg_dialog_save $dname
}

dialog gpg_options {
  title "GPG Authentication"
  size -1 -1 202 96
  option dbu
  text "Path to gpg.exe (usually C:\Program Files\GNU\GnuPG\gpg.exe):", 4, 5 4 185 9
  edit "", 6, 5 12 178 11, autohs limit 0
  button "...", 10, 185 12 12 11
  text "Passphrase (leave blank if you run /gpgauth manually for security reasons):", 5, 5 28 186 8
  edit "", 7, 5 37 192 11, pass
  check "Autorun after connection", 8, 5 54 90 8, disable
  check "Remove from popup menu (use /gpg_options)", 9, 5 66 126 7, disable
  button "Authenticate", 1, 4 79 44 12
  button "OK", 2, 71 79 40 12, ok
  button "Apply", 3, 157 79 40 12
  button "Cancel", 11, 114 79 40 12, cancel
}