From: Konrad Rosenbaum Date: Sun, 28 Apr 2013 19:29:17 +0000 (+0200) Subject: move away from tcl; add GPG X-Git-Url: http://git.silmor.de/gitweb/?a=commitdiff_plain;h=f254d42015d70253a140c60e4487a688bb05b3f0;p=web%2Fkonrad%2Faurora.git move away from tcl; add GPG --- diff --git a/.gitignore b/.gitignore index ea9eacb..041f332 100644 --- a/.gitignore +++ b/.gitignore @@ -5,9 +5,11 @@ libAurora* *.dll *.a *.lib +src/Makefile* #external tools tclkit* +gpg #other temp stuff tmp diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..ccecbd2 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,12 @@ +[submodule "gnupg"] + path = gnupg + url = git://git.gnupg.org/gnupg.git +[submodule "libassuan"] + path = libassuan + url = git://git.gnupg.org/libassuan.git +[submodule "gpgme"] + path = gpgme + url = git://git.gnupg.org/gpgme.git +[submodule "libgpg-error"] + path = libgpg-error + url = git://git.gnupg.org/libgpg-error.git diff --git a/README b/README index d9d268c..63859dc 100644 --- a/README +++ b/README @@ -1,55 +1,51 @@ README for Aurora ================== -(c) Konrad Rosenbaum, 2012 +(c) Konrad Rosenbaum, 2012-2013 protected under the GNU LGPL v.3 see LICENSE.LGPL for details for 3rd-party components' copyright see installer/libs -Aurora is a bootstrap installer and a library for program updates. +Aurora is a library for program updates. - -Update Library -=============== +Warning to Windows Fanatics: this library needs a lot of GNU tools to work. +I have actually no clue how you could build this library with Visual Studio! Requirements: -* Qt 4.8 or newer (5.x is untested, but might work) -* QCA 2.x +============== + +* Qt 5.x +* GnuPG/libassuan/GPGME (included as GIT submodules) +* GNU Autotools + -> Linux: install the autotools packages autoconf and automake + -> Windows: install MinGW and MSys Building the library: +====================== + +You have to build GPG first. Make sure you have all submodules: +git submodule init +git submodule update + +Build GPG: ./build-gpg.sh +For MinGW builds: do this inside the MSys shell +For VC builds: you are on your own, sorry. + + +Then build the actual Aurora library: cd src && qmake && make +For MinGW builds: do this in a normal cmd.exe shell, + MSys may behave unexpectedly +For VC builds: if you somehow translated GPGME, this will work with your + favourite way of building Qt projects Creating Packages ================== -...? +Create a ZIP file that contains the entire program. For Aurora this includes +the following: -Creating an Installer -====================== +libAurora.so* (or Aurora.dll) +gpg(.exe) (from gpg/bin/gpg(.exe)) -Requirements: -* TclKit, get it from: - - http://code.google.com/p/tclkit/wiki/TclkitDownloads - - or http://equi4.com/tclkit/download.html - -Includes some files from TclLib (http://tcllib.sourceforge.net/), -see installer/libs for details. - -Building an installer: -1) download a TclKit that fits your platform -2) place it in the main directory -3) create all the packages that belong to your application (see above) -4) create a manifest file (also see above) -5) copy the generated manifest to installer.vfs/manifest.xml -6) create the installer: - tclkit util/sdx.kit wrap installer.exe -runtime tclkit-upx.exe - * sdx.kit : wrapper application to build integrated executables - * installer.exe : "installer" plus the correct extension for your - platform, if you want to use a different name you must add the - option -vfs installer.vfs - * -runtime ...: the tclkit executable to use for the installer, - recommendation: use the 32bit tclkits for x86 based Linux and Windows, - use the UPX version for Windows (it is smaller than the normal one) - * Hint: on Windows you may to copy tclkit because it does not - allow to execute and read the same file at the same file. \ No newline at end of file diff --git a/build-gpg.sh b/build-gpg.sh new file mode 100755 index 0000000..2a13096 --- /dev/null +++ b/build-gpg.sh @@ -0,0 +1,49 @@ +set -e + +fmake(){ + echo -e 'all:\n\techo ok\n\ninstall:\n\techo ok\n\n' >./$1/Makefile +} + +cd gnupg +echo Building GnuPG +git clean -dfx +./autogen.sh +./configure --disable-gnupg-iconv --enable-minimal --disable-card-support --disable-bzip2 --disable-exec --disable-keyserver-helpers --disable-nls --disable-asm --disable-rpath --disable-regex --with-included-zlib --with-libcurl=no --disable-threads --without-libiconv-prefix --without-libintl-prefix --with-libusb=no --with-readline=no --prefix=`pwd`/../gpg --enable-rsa +fmake doc +make +make install + +cd .. +strip gpg/bin/gpg gpg/bin/gpg.exe || true + +cd libgpg-error +echo +echo Building libgpg-error +git clean -dfx +./autogen.sh +./configure --enable-static --disable-shared --disable-nls --disable-rpath --disable-languages --without-libiconv-prefix --without-libintl-prefix --prefix=`pwd`/../gpg +fmake doc +echo >po/LINGUAS +make +make install + +cd ../libassuan +echo +echo Building libassuan +git clean -dfx +./autogen.sh +./configure --enable-static --disable-shared --with-libgpg-error-prefix=`pwd`/../gpg --prefix=`pwd`/../gpg +fmake doc +make +make install + +cd ../gpgme +echo +echo Building GPGME +git clean -dfx +./autogen.sh +./configure --enable-static --disable-shared --disable-glibtest --disable-gpgsm-test --disable-gpgconf-test --disable-g13-test --with-gpg=`pwd`/../gpg/bin/gpg --prefix=`pwd`/../gpg --with-libassuan-prefix=`pwd`/../gpg --with-libgpg-error-prefix=`pwd`/../gpg +fmake doc +fmake tests +make +make install diff --git a/clean-gpg.sh b/clean-gpg.sh new file mode 100755 index 0000000..2595284 --- /dev/null +++ b/clean-gpg.sh @@ -0,0 +1,2 @@ +#!/bin/sh +for d in gnupg libassuan libgpg-error gpgme ; do ( cd $d ; git clean -dfx ) ; done diff --git a/file-format.txt b/file-format.txt deleted file mode 100644 index e59666a..0000000 --- a/file-format.txt +++ /dev/null @@ -1,42 +0,0 @@ -File Format -============= - -This is the format of the package and manifest files used by the Auto-Updater. - - -Package File --------------- - -This file type is used to transport files for installation or update. - -It is recommended to put each component into one separate package - e.g. one -for the actual application, one for plugins, one for Qt, etc. - this way it is -easier to do partion (security) updates. - -All numbers are 32bit big endian. - -Pos. Len. Content -0000 4 Magic Bytes 0x552d3837 -0004 4 Version Number: 0x000100 (i.e. 0.1.0) -0008 4 Amount of Directory entries -000c * compressed files - -Per Directory entry: -0000 4 Length of Filename -0004 4 Length of File compressed (0 indicates empty file or a directory) -0008 * Filename in UTF-8 encoding - n+8 * Packed file (non-existent if length indicated 0) - -Notes on Filenames: -* the directory separator is "/" -* components that consist of dots only make the file name illegal -* illegal file name means the file is ignored with a warning -* leading "/" is ignored, leading drive letter (Regexp: "[a-zA-Z]:") -* directory names end in "/" -* executable files end in "*" - the "*" is stripped off - -Manifest File ---------------- - -This file type describes which package files are needed for a specific -installation version and contains the Signature and Keys. \ No newline at end of file diff --git a/gnupg b/gnupg new file mode 160000 index 0000000..0bd168b --- /dev/null +++ b/gnupg @@ -0,0 +1 @@ +Subproject commit 0bd168bf8eecf4ec11c147edada0f08bebdc6cc0 diff --git a/gpgme b/gpgme new file mode 160000 index 0000000..ef5cd38 --- /dev/null +++ b/gpgme @@ -0,0 +1 @@ +Subproject commit ef5cd38123dfbef7843f374ee697b0b5e8730c46 diff --git a/installer.vfs/libs/license.terms b/installer.vfs/libs/license.terms deleted file mode 100644 index 45733c8..0000000 --- a/installer.vfs/libs/license.terms +++ /dev/null @@ -1,38 +0,0 @@ -This software is copyrighted by Ajuba Solutions and other parties. -The following terms apply to all files associated with the software unless -explicitly disclaimed in individual files. - -The authors hereby grant permission to use, copy, modify, distribute, -and license this software and its documentation for any purpose, provided -that existing copyright notices are retained in all copies and that this -notice is included verbatim in any distributions. No written agreement, -license, or royalty fee is required for any of the authorized uses. -Modifications to this software may be copyrighted by their authors -and need not follow the licensing terms described here, provided that -the new terms are clearly indicated on the first page of each file where -they apply. - -IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY -FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES -ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY -DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGE. - -THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE -IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE -NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR -MODIFICATIONS. - -GOVERNMENT USE: If you are acquiring this software on behalf of the -U.S. government, the Government shall have only "Restricted Rights" -in the software and related documentation as defined in the Federal -Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you -are acquiring the software on behalf of the Department of Defense, the -software shall be classified as "Commercial Computer Software" and the -Government shall have only "Restricted Rights" as defined in Clause -252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the -authors grant the U.S. Government and others acting in its behalf -permission to use and distribute the software in accordance with the -terms specified in this license. diff --git a/installer.vfs/libs/sha256.tcl b/installer.vfs/libs/sha256.tcl deleted file mode 100644 index dc0953c..0000000 --- a/installer.vfs/libs/sha256.tcl +++ /dev/null @@ -1,837 +0,0 @@ -# sha256.tcl - Copyright (C) 2005 Pat Thoyts -# -# SHA1 defined by FIPS 180-2, "The Secure Hash Standard" -# HMAC defined by RFC 2104, "Keyed-Hashing for Message Authentication" -# -# This is an implementation of the secure hash algorithms specified in the -# FIPS 180-2 document. -# -# This implementation permits incremental updating of the hash and -# provides support for external compiled implementations using critcl. -# -# This implementation permits incremental updating of the hash and -# provides support for external compiled implementations either using -# critcl (sha256c). -# -# Ref: http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf -# http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf -# -# ------------------------------------------------------------------------- -# See the file "license.terms" for information on usage and redistribution -# of this file, and for a DISCLAIMER OF ALL WARRANTIES. -# ------------------------------------------------------------------------- -# - -# @mdgen EXCLUDE: sha256c.tcl - -package require Tcl 8.2; # tcl minimum version - -namespace eval ::sha2 { - variable version 1.0.3 - variable rcsid {$Id: sha256.tcl,v 1.7 2010/07/06 20:16:39 andreas_kupries Exp $} - - variable accel - array set accel {tcl 0 critcl 0} - variable loaded {} - - namespace export sha256 hmac \ - SHA256Init SHA256Update SHA256Final - - variable uid - if {![info exists uid]} { - set uid 0 - } - - variable K - if {![info exists K]} { - # FIPS 180-2: 4.2.2 SHA-256 constants - set K [list \ - 0x428a2f98 0x71374491 0xb5c0fbcf 0xe9b5dba5 \ - 0x3956c25b 0x59f111f1 0x923f82a4 0xab1c5ed5 \ - 0xd807aa98 0x12835b01 0x243185be 0x550c7dc3 \ - 0x72be5d74 0x80deb1fe 0x9bdc06a7 0xc19bf174 \ - 0xe49b69c1 0xefbe4786 0x0fc19dc6 0x240ca1cc \ - 0x2de92c6f 0x4a7484aa 0x5cb0a9dc 0x76f988da \ - 0x983e5152 0xa831c66d 0xb00327c8 0xbf597fc7 \ - 0xc6e00bf3 0xd5a79147 0x06ca6351 0x14292967 \ - 0x27b70a85 0x2e1b2138 0x4d2c6dfc 0x53380d13 \ - 0x650a7354 0x766a0abb 0x81c2c92e 0x92722c85 \ - 0xa2bfe8a1 0xa81a664b 0xc24b8b70 0xc76c51a3 \ - 0xd192e819 0xd6990624 0xf40e3585 0x106aa070 \ - 0x19a4c116 0x1e376c08 0x2748774c 0x34b0bcb5 \ - 0x391c0cb3 0x4ed8aa4a 0x5b9cca4f 0x682e6ff3 \ - 0x748f82ee 0x78a5636f 0x84c87814 0x8cc70208 \ - 0x90befffa 0xa4506ceb 0xbef9a3f7 0xc67178f2 \ - ] - } - -} - -# ------------------------------------------------------------------------- -# Management of sha256 implementations. - -# LoadAccelerator -- -# -# This package can make use of a number of compiled extensions to -# accelerate the digest computation. This procedure manages the -# use of these extensions within the package. During normal usage -# this should not be called, but the test package manipulates the -# list of enabled accelerators. -# -proc ::sha2::LoadAccelerator {name} { - variable accel - set r 0 - switch -exact -- $name { - tcl { - # Already present (this file) - set r 1 - } - critcl { - if {![catch {package require tcllibc}] - || ![catch {package require sha256c}]} { - set r [expr {[info command ::sha2::sha256c_update] != {}}] - } - } - default { - return -code error "invalid accelerator $key:\ - must be one of [join [KnownImplementations] {, }]" - } - } - set accel($name) $r - return $r -} - -# ::sha2::Implementations -- -# -# Determines which implementations are -# present, i.e. loaded. -# -# Arguments: -# None. -# -# Results: -# A list of implementation keys. - -proc ::sha2::Implementations {} { - variable accel - set res {} - foreach n [array names accel] { - if {!$accel($n)} continue - lappend res $n - } - return $res -} - -# ::sha2::KnownImplementations -- -# -# Determines which implementations are known -# as possible implementations. -# -# Arguments: -# None. -# -# Results: -# A list of implementation keys. In the order -# of preference, most prefered first. - -proc ::sha2::KnownImplementations {} { - return {critcl tcl} -} - -proc ::sha2::Names {} { - return { - critcl {tcllibc based} - tcl {pure Tcl} - } -} - -# ::sha2::SwitchTo -- -# -# Activates a loaded named implementation. -# -# Arguments: -# key Name of the implementation to activate. -# -# Results: -# None. - -proc ::sha2::SwitchTo {key} { - variable accel - variable loaded - - if {[string equal $key $loaded]} { - # No change, nothing to do. - return - } elseif {![string equal $key ""]} { - # Validate the target implementation of the switch. - - if {![info exists accel($key)]} { - return -code error "Unable to activate unknown implementation \"$key\"" - } elseif {![info exists accel($key)] || !$accel($key)} { - return -code error "Unable to activate missing implementation \"$key\"" - } - } - - # Deactivate the previous implementation, if there was any. - - if {![string equal $loaded ""]} { - foreach c { - SHA256Init SHA224Init - SHA256Final SHA224Final - SHA256Update - } { - rename ::sha2::$c ::sha2::${c}-${loaded} - } - } - - # Activate the new implementation, if there is any. - - if {![string equal $key ""]} { - foreach c { - SHA256Init SHA224Init - SHA256Final SHA224Final - SHA256Update - } { - rename ::sha2::${c}-${key} ::sha2::$c - } - } - - # Remember the active implementation, for deactivation by future - # switches. - - set loaded $key - return -} - -# ------------------------------------------------------------------------- - -# SHA256Init -- -# -# Create and initialize an SHA256 state variable. This will be -# cleaned up when we call SHA256Final -# - -proc ::sha2::SHA256Init-tcl {} { - variable uid - set token [namespace current]::[incr uid] - upvar #0 $token tok - - # FIPS 180-2: 5.3.2 Setting the initial hash value - array set tok \ - [list \ - A [expr {int(0x6a09e667)}] \ - B [expr {int(0xbb67ae85)}] \ - C [expr {int(0x3c6ef372)}] \ - D [expr {int(0xa54ff53a)}] \ - E [expr {int(0x510e527f)}] \ - F [expr {int(0x9b05688c)}] \ - G [expr {int(0x1f83d9ab)}] \ - H [expr {int(0x5be0cd19)}] \ - n 0 i "" v 256] - return $token -} - -proc ::sha2::SHA256Init-critcl {} { - variable uid - set token [namespace current]::[incr uid] - upvar #0 $token tok - - # FIPS 180-2: 5.3.2 Setting the initial hash value - set tok(sha256c) [sha256c_init256] - return $token -} - -# SHA256Update -- -# -# This is called to add more data into the hash. You may call this -# as many times as you require. Note that passing in "ABC" is equivalent -# to passing these letters in as separate calls -- hence this proc -# permits hashing of chunked data -# -# If we have a C-based implementation available, then we will use -# it here in preference to the pure-Tcl implementation. -# - -proc ::sha2::SHA256Update-tcl {token data} { - upvar #0 $token state - - # Update the state values - incr state(n) [string length $data] - append state(i) $data - - # Calculate the hash for any complete blocks - set len [string length $state(i)] - for {set n 0} {($n + 64) <= $len} {} { - SHA256Transform $token [string range $state(i) $n [incr n 64]] - } - - # Adjust the state for the blocks completed. - set state(i) [string range $state(i) $n end] - return -} - -proc ::sha2::SHA256Update-critcl {token data} { - upvar #0 $token state - - set state(sha256c) [sha256c_update $data $state(sha256c)] - return -} - -# SHA256Final -- -# -# This procedure is used to close the current hash and returns the -# hash data. Once this procedure has been called the hash context -# is freed and cannot be used again. -# -# Note that the output is 256 bits represented as binary data. -# - -proc ::sha2::SHA256Final-tcl {token} { - upvar #0 $token state - SHA256Penultimate $token - - # Output - set r [bytes $state(A)][bytes $state(B)][bytes $state(C)][bytes $state(D)][bytes $state(E)][bytes $state(F)][bytes $state(G)][bytes $state(H)] - unset state - return $r -} - -proc ::sha2::SHA256Final-critcl {token} { - upvar #0 $token state - set r $state(sha256c) - unset state - return $r -} - -# SHA256Penultimate -- -# -# -proc ::sha2::SHA256Penultimate {token} { - upvar #0 $token state - - # FIPS 180-2: 5.1.1: Padding the message - # - set len [string length $state(i)] - set pad [expr {56 - ($len % 64)}] - if {$len % 64 > 56} { - incr pad 64 - } - if {$pad == 0} { - incr pad 64 - } - append state(i) [binary format a$pad \x80] - - # Append length in bits as big-endian wide int. - set dlen [expr {8 * $state(n)}] - append state(i) [binary format II 0 $dlen] - - # Calculate the hash for the remaining block. - set len [string length $state(i)] - for {set n 0} {($n + 64) <= $len} {} { - SHA256Transform $token [string range $state(i) $n [incr n 64]] - } -} - -# ------------------------------------------------------------------------- - -proc ::sha2::SHA224Init-tcl {} { - variable uid - set token [namespace current]::[incr uid] - upvar #0 $token tok - - # FIPS 180-2 (change notice 1) (1): SHA-224 initialization values - array set tok \ - [list \ - A [expr {int(0xc1059ed8)}] \ - B [expr {int(0x367cd507)}] \ - C [expr {int(0x3070dd17)}] \ - D [expr {int(0xf70e5939)}] \ - E [expr {int(0xffc00b31)}] \ - F [expr {int(0x68581511)}] \ - G [expr {int(0x64f98fa7)}] \ - H [expr {int(0xbefa4fa4)}] \ - n 0 i "" v 224] - return $token -} - -proc ::sha2::SHA224Init-critcl {} { - variable uid - set token [namespace current]::[incr uid] - upvar #0 $token tok - - # FIPS 180-2 (change notice 1) (1): SHA-224 initialization values - set tok(sha256c) [sha256c_init224] - return $token -} - -interp alias {} ::sha2::SHA224Update {} ::sha2::SHA256Update - -proc ::sha2::SHA224Final-tcl {token} { - upvar #0 $token state - SHA256Penultimate $token - - # Output - set r [bytes $state(A)][bytes $state(B)][bytes $state(C)][bytes $state(D)][bytes $state(E)][bytes $state(F)][bytes $state(G)] - unset state - return $r -} - -proc ::sha2::SHA224Final-critcl {token} { - upvar #0 $token state - # Trim result down to 224 bits (by 4 bytes). - # See output below, A..G, not A..H - set r [string range $state(sha256c) 0 end-4] - unset state - return $r -} - -# ------------------------------------------------------------------------- -# HMAC Hashed Message Authentication (RFC 2104) -# -# hmac = H(K xor opad, H(K xor ipad, text)) -# - -# HMACInit -- -# -# This is equivalent to the SHA1Init procedure except that a key is -# added into the algorithm -# -proc ::sha2::HMACInit {K} { - - # Key K is adjusted to be 64 bytes long. If K is larger, then use - # the SHA1 digest of K and pad this instead. - set len [string length $K] - if {$len > 64} { - set tok [SHA256Init] - SHA256Update $tok $K - set K [SHA256Final $tok] - set len [string length $K] - } - set pad [expr {64 - $len}] - append K [string repeat \0 $pad] - - # Cacluate the padding buffers. - set Ki {} - set Ko {} - binary scan $K i16 Ks - foreach k $Ks { - append Ki [binary format i [expr {$k ^ 0x36363636}]] - append Ko [binary format i [expr {$k ^ 0x5c5c5c5c}]] - } - - set tok [SHA256Init] - SHA256Update $tok $Ki; # initialize with the inner pad - - # preserve the Ko value for the final stage. - # FRINK: nocheck - set [subst $tok](Ko) $Ko - - return $tok -} - -# HMACUpdate -- -# -# Identical to calling SHA256Update -# -proc ::sha2::HMACUpdate {token data} { - SHA256Update $token $data - return -} - -# HMACFinal -- -# -# This is equivalent to the SHA256Final procedure. The hash context is -# closed and the binary representation of the hash result is returned. -# -proc ::sha2::HMACFinal {token} { - upvar #0 $token state - - set tok [SHA256Init]; # init the outer hashing function - SHA256Update $tok $state(Ko); # prepare with the outer pad. - SHA256Update $tok [SHA256Final $token]; # hash the inner result - return [SHA256Final $tok] -} - -# ------------------------------------------------------------------------- -# Description: -# This is the core SHA1 algorithm. It is a lot like the MD4 algorithm but -# includes an extra round and a set of constant modifiers throughout. -# -set ::sha2::SHA256Transform_body { - variable K - upvar #0 $token state - - # FIPS 180-2: 6.2.2 SHA-256 Hash computation. - binary scan $msg I* blocks - set blockLen [llength $blocks] - for {set i 0} {$i < $blockLen} {incr i 16} { - set W [lrange $blocks $i [expr {$i+15}]] - - # FIPS 180-2: 6.2.2 (1) Prepare the message schedule - # For t = 16 to 64 - # let Wt = (sigma1(Wt-2) + Wt-7 + sigma0(Wt-15) + Wt-16) - set t2 13 - set t7 8 - set t15 0 - set t16 -1 - for {set t 16} {$t < 64} {incr t} { - lappend W [expr {([sigma1 [lindex $W [incr t2]]] \ - + [lindex $W [incr t7]] \ - + [sigma0 [lindex $W [incr t15]]] \ - + [lindex $W [incr t16]]) & 0xffffffff}] - } - - # FIPS 180-2: 6.2.2 (2) Initialise the working variables - set A $state(A) - set B $state(B) - set C $state(C) - set D $state(D) - set E $state(E) - set F $state(F) - set G $state(G) - set H $state(H) - - # FIPS 180-2: 6.2.2 (3) Do permutation rounds - # For t = 0 to 63 do - # T1 = h + SIGMA1(e) + Ch(e,f,g) + Kt + Wt - # T2 = SIGMA0(a) + Maj(a,b,c) - # h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; - # a = T1 + T2 - # - for {set t 0} {$t < 64} {incr t} { - set T1 [expr {($H + [SIGMA1 $E] + [Ch $E $F $G] - + [lindex $K $t] + [lindex $W $t]) & 0xffffffff}] - set T2 [expr {([SIGMA0 $A] + [Maj $A $B $C]) & 0xffffffff}] - set H $G - set G $F - set F $E - set E [expr {($D + $T1) & 0xffffffff}] - set D $C - set C $B - set B $A - set A [expr {($T1 + $T2) & 0xffffffff}] - } - - # FIPS 180-2: 6.2.2 (4) Compute the intermediate hash - incr state(A) $A - incr state(B) $B - incr state(C) $C - incr state(D) $D - incr state(E) $E - incr state(F) $F - incr state(G) $G - incr state(H) $H - } - - return -} - -# ------------------------------------------------------------------------- - -# FIPS 180-2: 4.1.2 equation 4.2 -proc ::sha2::Ch {x y z} { - return [expr {($x & $y) ^ (~$x & $z)}] -} - -# FIPS 180-2: 4.1.2 equation 4.3 -proc ::sha2::Maj {x y z} { - return [expr {($x & $y) ^ ($x & $z) ^ ($y & $z)}] -} - -# FIPS 180-2: 4.1.2 equation 4.4 -# (x >>> 2) ^ (x >>> 13) ^ (x >>> 22) -proc ::sha2::SIGMA0 {x} { - return [expr {[>>> $x 2] ^ [>>> $x 13] ^ [>>> $x 22]}] -} - -# FIPS 180-2: 4.1.2 equation 4.5 -# (x >>> 6) ^ (x >>> 11) ^ (x >>> 25) -proc ::sha2::SIGMA1 {x} { - return [expr {[>>> $x 6] ^ [>>> $x 11] ^ [>>> $x 25]}] -} - -# FIPS 180-2: 4.1.2 equation 4.6 -# s0 = (x >>> 7) ^ (x >>> 18) ^ (x >> 3) -proc ::sha2::sigma0 {x} { - #return [expr {[>>> $x 7] ^ [>>> $x 18] ^ (($x >> 3) & 0x1fffffff)}] - return [expr {((($x<<25) | (($x>>7) & (0x7FFFFFFF>>6))) \ - ^ (($x<<14) | (($x>>18) & (0x7FFFFFFF>>17))) & 0xFFFFFFFF) \ - ^ (($x>>3) & 0x1fffffff)}] -} - -# FIPS 180-2: 4.1.2 equation 4.7 -# s1 = (x >>> 17) ^ (x >>> 19) ^ (x >> 10) -proc ::sha2::sigma1 {x} { - #return [expr {[>>> $x 17] ^ [>>> $x 19] ^ (($x >> 10) & 0x003fffff)}] - return [expr {((($x<<15) | (($x>>17) & (0x7FFFFFFF>>16))) \ - ^ (($x<<13) | (($x>>19) & (0x7FFFFFFF>>18))) & 0xFFFFFFFF) \ - ^ (($x >> 10) & 0x003fffff)}] -} - -# 32bit rotate-right -proc ::sha2::>>> {v n} { - return [expr {(($v << (32 - $n)) \ - | (($v >> $n) & (0x7FFFFFFF >> ($n - 1)))) \ - & 0xFFFFFFFF}] -} - -# 32bit rotate-left -proc ::sha2::<<< {v n} { - return [expr {((($v << $n) \ - | (($v >> (32 - $n)) \ - & (0x7FFFFFFF >> (31 - $n))))) \ - & 0xFFFFFFFF}] -} - -# ------------------------------------------------------------------------- -# We speed up the SHA256Transform code while maintaining readability in the -# source code by substituting inline for a number of functions. -# The idea is to reduce the number of [expr] calls. - -# Inline the Ch function -regsub -all -line \ - {\[Ch (\$[ABCDEFGH]) (\$[ABCDEFGH]) (\$[ABCDEFGH])\]} \ - $::sha2::SHA256Transform_body \ - {((\1 \& \2) ^ ((~\1) \& \3))} \ - ::sha2::SHA256Transform_body - -# Inline the Maj function -regsub -all -line \ - {\[Maj (\$[ABCDEFGH]) (\$[ABCDEFGH]) (\$[ABCDEFGH])\]} \ - $::sha2::SHA256Transform_body \ - {((\1 \& \2) ^ (\1 \& \3) ^ (\2 \& \3))} \ - ::sha2::SHA256Transform_body - - -# Inline the SIGMA0 function -regsub -all -line \ - {\[SIGMA0 (\$[ABCDEFGH])\]} \ - $::sha2::SHA256Transform_body \ - {((((\1<<30) | ((\1>>2) \& (0x7FFFFFFF>>1))) \& 0xFFFFFFFF) \ - ^ (((\1<<19) | ((\1>>13) \& (0x7FFFFFFF>>12))) \& 0xFFFFFFFF) \ - ^ (((\1<<10) | ((\1>>22) \& (0x7FFFFFFF>>21))) \& 0xFFFFFFFF) \ - )} \ - ::sha2::SHA256Transform_body - -# Inline the SIGMA1 function -regsub -all -line \ - {\[SIGMA1 (\$[ABCDEFGH])\]} \ - $::sha2::SHA256Transform_body \ - {((((\1<<26) | ((\1>>6) \& (0x7FFFFFFF>>5))) \& 0xFFFFFFFF) \ - ^ (((\1<<21) | ((\1>>11) \& (0x7FFFFFFF>>10))) \& 0xFFFFFFFF) \ - ^ (((\1<<7) | ((\1>>25) \& (0x7FFFFFFF>>24))) \& 0xFFFFFFFF) \ - )} \ - ::sha2::SHA256Transform_body - -proc ::sha2::SHA256Transform {token msg} $::sha2::SHA256Transform_body - -# ------------------------------------------------------------------------- - -# Convert a integer value into a binary string in big-endian order. -proc ::sha2::byte {n v} {expr {((0xFF << (8 * $n)) & $v) >> (8 * $n)}} -proc ::sha2::bytes {v} { - #format %c%c%c%c [byte 3 $v] [byte 2 $v] [byte 1 $v] [byte 0 $v] - format %c%c%c%c \ - [expr {((0xFF000000 & $v) >> 24) & 0xFF}] \ - [expr {(0xFF0000 & $v) >> 16}] \ - [expr {(0xFF00 & $v) >> 8}] \ - [expr {0xFF & $v}] -} - -# ------------------------------------------------------------------------- - -proc ::sha2::Hex {data} { - binary scan $data H* result - return $result -} - -# ------------------------------------------------------------------------- - -# Description: -# Pop the nth element off a list. Used in options processing. -# -proc ::sha2::Pop {varname {nth 0}} { - upvar $varname args - set r [lindex $args $nth] - set args [lreplace $args $nth $nth] - return $r -} - -# ------------------------------------------------------------------------- - -# fileevent handler for chunked file hashing. -# -proc ::sha2::Chunk {token channel {chunksize 4096}} { - upvar #0 $token state - - if {[eof $channel]} { - fileevent $channel readable {} - set state(reading) 0 - } - - SHA256Update $token [read $channel $chunksize] -} - -# ------------------------------------------------------------------------- - -proc ::sha2::_sha256 {ver args} { - array set opts {-hex 0 -filename {} -channel {} -chunksize 4096} - if {[llength $args] == 1} { - set opts(-hex) 1 - } else { - while {[string match -* [set option [lindex $args 0]]]} { - switch -glob -- $option { - -hex { set opts(-hex) 1 } - -bin { set opts(-hex) 0 } - -file* { set opts(-filename) [Pop args 1] } - -channel { set opts(-channel) [Pop args 1] } - -chunksize { set opts(-chunksize) [Pop args 1] } - default { - if {[llength $args] == 1} { break } - if {[string compare $option "--"] == 0} { Pop args; break } - set err [join [lsort [concat -bin [array names opts]]] ", "] - return -code error "bad option $option:\ - must be one of $err" - } - } - Pop args - } - } - - if {$opts(-filename) != {}} { - set opts(-channel) [open $opts(-filename) r] - fconfigure $opts(-channel) -translation binary - } - - if {$opts(-channel) == {}} { - - if {[llength $args] != 1} { - return -code error "wrong # args: should be\ - \"[namespace current]::sha$ver ?-hex|-bin? -filename file\ - | -channel channel | string\"" - } - set tok [SHA${ver}Init] - SHA${ver}Update $tok [lindex $args 0] - set r [SHA${ver}Final $tok] - - } else { - - set tok [SHA${ver}Init] - # FRINK: nocheck - set [subst $tok](reading) 1 - fileevent $opts(-channel) readable \ - [list [namespace origin Chunk] \ - $tok $opts(-channel) $opts(-chunksize)] - # FRINK: nocheck - vwait [subst $tok](reading) - set r [SHA${ver}Final $tok] - - # If we opened the channel - we should close it too. - if {$opts(-filename) != {}} { - close $opts(-channel) - } - } - - if {$opts(-hex)} { - set r [Hex $r] - } - return $r -} - -interp alias {} ::sha2::sha256 {} ::sha2::_sha256 256 -interp alias {} ::sha2::sha224 {} ::sha2::_sha256 224 - -# ------------------------------------------------------------------------- - -proc ::sha2::hmac {args} { - array set opts {-hex 1 -filename {} -channel {} -chunksize 4096} - if {[llength $args] != 2} { - while {[string match -* [set option [lindex $args 0]]]} { - switch -glob -- $option { - -key { set opts(-key) [Pop args 1] } - -hex { set opts(-hex) 1 } - -bin { set opts(-hex) 0 } - -file* { set opts(-filename) [Pop args 1] } - -channel { set opts(-channel) [Pop args 1] } - -chunksize { set opts(-chunksize) [Pop args 1] } - default { - if {[llength $args] == 1} { break } - if {[string compare $option "--"] == 0} { Pop args; break } - set err [join [lsort [array names opts]] ", "] - return -code error "bad option $option:\ - must be one of $err" - } - } - Pop args - } - } - - if {[llength $args] == 2} { - set opts(-key) [Pop args] - } - - if {![info exists opts(-key)]} { - return -code error "wrong # args:\ - should be \"hmac ?-hex? -key key -filename file | string\"" - } - - if {$opts(-filename) != {}} { - set opts(-channel) [open $opts(-filename) r] - fconfigure $opts(-channel) -translation binary - } - - if {$opts(-channel) == {}} { - - if {[llength $args] != 1} { - return -code error "wrong # args:\ - should be \"hmac ?-hex? -key key -filename file | string\"" - } - set tok [HMACInit $opts(-key)] - HMACUpdate $tok [lindex $args 0] - set r [HMACFinal $tok] - - } else { - - set tok [HMACInit $opts(-key)] - # FRINK: nocheck - set [subst $tok](reading) 1 - fileevent $opts(-channel) readable \ - [list [namespace origin Chunk] \ - $tok $opts(-channel) $opts(-chunksize)] - # FRINK: nocheck - vwait [subst $tok](reading) - set r [HMACFinal $tok] - - # If we opened the channel - we should close it too. - if {$opts(-filename) != {}} { - close $opts(-channel) - } - } - - if {$opts(-hex)} { - set r [Hex $r] - } - return $r -} - -# ------------------------------------------------------------------------- - -# Try and load a compiled extension to help. -namespace eval ::sha2 { - variable e {} - foreach e [KnownImplementations] { - if {[LoadAccelerator $e]} { - SwitchTo $e - break - } - } - unset e -} - -package provide sha256 $::sha2::version - -# ------------------------------------------------------------------------- -# Local Variables: -# mode: tcl -# indent-tabs-mode: nil -# End: diff --git a/libassuan b/libassuan new file mode 160000 index 0000000..7d227ac --- /dev/null +++ b/libassuan @@ -0,0 +1 @@ +Subproject commit 7d227acff329a921f76cd4c391d7cbae40115672 diff --git a/libgpg-error b/libgpg-error new file mode 160000 index 0000000..3367ff0 --- /dev/null +++ b/libgpg-error @@ -0,0 +1 @@ +Subproject commit 3367ff0aa51b6685e37b749b3179643b82d23064 diff --git a/src/aurora.cpp b/src/aurora.cpp index 7f6c476..ea5de4c 100644 --- a/src/aurora.cpp +++ b/src/aurora.cpp @@ -4,10 +4,121 @@ // #include "aurora.h" +#include "aurora_p.h" #include +#include +#include -void initAurora(const QString& file) +struct AuroraPrivate { - qDebug()<<"If I knew how I would grab my gun and bring in this cat:"<url=u; + QSettings c;c.beginGroup(AuroraGroup); + c.setValue("baseurl",u); + startPoll(); +} + +QUrl Aurora::baseUrl() const +{ + return d->url; +} + +Aurora::State Aurora::state() const +{ + return d->state; +} + +int Aurora::pollInterVall() const +{ + return d->pollint; } + +void Aurora::setPollIntervall(int seconds) +{ + if(seconds<0)seconds=0; + startPoll(seconds); +} + +void Aurora::startPoll(int intervalInSeconds) +{ + if(intervalInSeconds>=0) + d->pollint=intervalInSeconds; + if(d->polltmr){ + delete d->polltmr; + d->polltmr=0; + if(!d->isBlocking()) + d->state=Initializing; + } + if(d->pollint>0){ + d->polltmr=new QTimer(this); + connect(d->polltmr,SIGNAL(timeout()), this,SLOT(pollnow())); + d->polltmr->start(d->pollint); + if(!d->isBlocking()) + d->state=Polling; + } +} + +bool Aurora::isReadyForDownload() const +{ + return false; //TODO +} + +bool Aurora::isReadyForInstall() const +{ + return false; //TODO +} + + +void Aurora::pollnow() +{ + if(d->isBlocking()){ + qDebug()<<"missing an update poll cycle, in blocking mode"; + return; + } +} + +void Aurora::startDownload() +{ + +} + +void Aurora::startInstallation() +{ + +} + diff --git a/src/aurora.h b/src/aurora.h index f32ab1f..ef2c4d9 100644 --- a/src/aurora.h +++ b/src/aurora.h @@ -7,9 +7,61 @@ #define AURORA_MAIN_H #include +#include +#include -///initialize the Aurora lib and start the update checks -/// \param file the name of the file that contains the manifest of the current install -void initAurora(const QString&file); +class AuroraPrivate; +class Aurora:public QObject +{ + Q_OBJECT + public: + explicit Aurora(QObject*parent=0); + virtual ~Aurora(); + + QUrl baseUrl()const; + + enum State{ + Initializing=0, + Polling=1, + Checking=5, + Downloading=2, + Installing=3, + PostInstall=4 + }; + + enum DownloadResult{ + Ok=0, + NetworkError=1, + SslError=2, + SignatureFailed=3 + }; + + State state()const; + + bool isReadyForDownload()const; + bool isReadyForInstall()const; + + int pollInterVall()const; + + public slots: + void setBaseUrl(QUrl); + void startPoll(int intervalInSeconds=-1); + void setPollIntervall(int seconds); + void startDownload(); + void startInstallation(); + signals: + void newVersionAvailable(const QString&); + void versionSignatureFailed(const QString&); + void readyForInstallation(); + void downloadFailed(); + void downloadProgress(int,int); + void installationFinished(); + void installationFailed(); + + private slots: + void pollnow(); + private: + AuroraPrivate *d; +}; #endif diff --git a/src/aurora.pro b/src/aurora.pro index 0a70e95..6ed1973 100644 --- a/src/aurora.pro +++ b/src/aurora.pro @@ -9,7 +9,7 @@ OBJECTS_DIR = .ctmp MOC_DIR = .ctmp RCC_DIR = .ctmp -VERSION = 0.1.0 +VERSION = 0.2.0 SOURCES += aurora.cpp diff --git a/util/sdx.kit b/util/sdx.kit deleted file mode 100644 index 4c70d7e..0000000 Binary files a/util/sdx.kit and /dev/null differ