Add .gitlab-ci.yml

Version 0.5.0 - upgrade dependencies

Upgrade all dependencies. In particular to avoid a jquery vulnerability.

Merge remote-tracking branch 'alster/feature/extra-signup-params'

Merge remote-tracking branch 'alster/add-ci' into master

Allow extra signup params from account

For the feature/invite-codes in leap_web, we need to be able to pass an
extra parameter (the invite code) from the signup form to the server.
This approach allows the consumer of SRP to specify a custom
implementation of Account that returns arbitrary `loginParams`, and
Session will pass them on so that they become part of the XHR.

- Split session.signup into signup and update to restrict extra params
  to signup only

Bump version to 0.4.0

Remove jasmine html runner & outdated libs

Run tests via cli using karma & PhantomJS for Travis

Instead of jasmine's HTML runner, use karma to run specs. karma & all
other dependencies are installed via npm and executed via node.js. This
allows TravisCI to execute the test, and as a side effect, bumps the
versions on the testing toolchain.

- Install node.js
- Run `npm install` once to download dependencies.
- Run `npm test` to run all tests

Things to bear in mind:
- This commit adds general project information in `package.js`
- `karma.conf.js` specifies the order in which src, spec and lib files
  are loaded
- Switch to jasmine spies instead of sinon

Merge pull request #4 from azul/bugfix/utf8-in-sha

properly treat utf8 chars in password

properly treat utf8 chars in password

utf-8 encoding used to be bundled with the SHA256 library. However we
only want to utf8 encode strings that are actual user input. We do not
want to encode the bytearrays that are used when hashing the hex values
calculated during for SRP.

So I separated the utf-8 encoding and the sha256 hashing.

Merge pull request #3 from azul/feature/use-token-auth

use token from the form to submit password update

use token from the form to submit password update

also zeroprefix the salt if needed

Now what else can you possibly zeroprefix?
This should be it - shouldn't it?

prefix incoming B too

also prefix our own toString(16) hex values

the 0 prefix in hex is essential for building the M and M2 strings

Merge pull request #2 from elijh/feature/always-use-v1

always use the API-only controller for all requests.

always use the API-only controller for all requests.

Merge pull request #1 from azul/refactor/separate-session

Refactor/separate session

refactor: separate account from session

refactor: rename constants to calculate and clean up hash usage

refactor: separate calculations from session

fix bug wrt zero padding of hashes

Merge branch 'release/0.3.0'

added version file

use a proper random a for the handshake

API: update instead of addToForm

addToForm was an attempt to not use ajax but just the normal form submit.

Turns out it's easy to add hidden fields to the form but quite cumbersome to remove the password fields from teh form so they are not submitted over the eventually untrusted channel.

So we use ajax for updates just like for signup.

addToForm: add the srp signup data to an existing form

don't cache password and login

catch empty responses

using done/fail instead of success/error, handing all properties to fail

all request should go to absolute paths

They should be independent of the url we're serving the page from

make sure we get the current password and login

make sure srp.login also works as a callback

sending the parsed json object to the error handler

Merge branch 'feature/clean-srp' into develop

further cleanup

removed the SRP class - using just a plain srp object now

first step at cleaning up the srp

works - but not quite what i want. Exposing jqXHR to error function

Merge branch 'release/0.2.0'

Merge branch 'feature/cleanup-non-restful' into develop

cleaned up unused parser functions

removed outdated django remote and all related files

Also cleaned up the specs a bit

Merge branch 'feature-updated_json_api' into develop

adopting tests to new .json urls

specifying charset and fetching jquery remotely

This way you don't have to add jquery to the lib dir for specs to work

Merge branch 'master' into feature-updated_json_api

we're expecting json responses - so put .json in the url

don't expect create to return an ok

* it returns the user
* it will return errors if sth. goes wrong.

require srp.js first and the remotes afterwards

added success and error callbacks to register

hand success and error messages to identify by default

also cleaned up some other parts that were not needed anymore

use M2 as the key for the server auth

not caching x,V,salt to avoid conflicts

added unit tests for session calculations

expecting the salt to be send with key salt

Merge branch 'feature-jquery-remote' into develop

all rest tests passing, using proper verbs

calculating the right M and M2!

still missing some error handling, this in Django specs and the right http verbs

got SRP v6a test setup and basic rest flow to work

* still need to fix the algo for auth
* Also need to get the http verbs right

got signup to work in accordance with py srp

using jquery for signup post now. login still pending

fixed restful signup test

first round of making jslint happy

moved srp-js files from lib to src

moved on with refactoring

* srp_register now is part of srp.js
* moved server specific stuff into plainXHR (such as fetching the seed from the server)
* fixed tests

seperated session from the srp flow - login tests pass, signup fail

started implementing a restful signup

copied jqueryRest and restful specs from django

no real change yet

moved all xhr related stuff to a seperate class

We can replace this if we want to use jquery ajax or similar. Also this has all the urls so it's super easy to overwrite

expose function to create salt

calcV to calculate verifier, do not use srp_url or srp_server anymore

We can easily overwrite the corresponding functions

moved src to lib and use relative path in require_tree

Merge branch 'master' of git://github.com/leapcode/srp-js

added an index file to use with sprockets

added an index file to use with sprockets

INCOMPATIBLE: major restructuring of the repository

* removed Django code - we're keeping the tests - so I hope the two can still be used together
* removed js packer - everyone has their own packaging strategy these days
* cleaned up the repository - we only have js so javascript directory does not make much sense

reject server response with error message if B=0

expectRequest and respond{JSON,XML} functions to simplify the tests

refactoring the tests a bit

parsing JSON responses tested and fixed

factored out parsing the responses

check for ready state and status before callback

changed indentation to the 2 spaces i love

added integration test for login

* added a small hook in srp to set a, A and Astr for testing
* moved generic functions for tests to SpecHelper

Connection Header is not allowed according to xhr spec.

Not sure if this was needed. Tests will throw exceptions when it's in but maybe some legacy browsers require it.

added tests for registration with jasmin and sinon

adding license remark in readme

added Readme from the original project site

This adds a file 'utils.py' to simplify templating.

Functions exist to create headers that include javascript files, and create javascript functions for login and registration. There are also
functions that create login and registration forms.

These functions don't necessarily account for everything a web developer might want to do, but it should simplify things for most developers and
provide guidelines for developers who want to build on top of this functionality.

Views.py now builds the login and register pages based on these functions. The register page now uses the login.html template, and the
register.html template should be deleted in the next release.

Fixed bug in views.py, changed files named 'hash' to 'crypto' since it now includes AES.

Added support for logins without javascript. This is configurable on a site-by-site basis.

Rather than passing the necessary parameters to the SRP constructor, I've made them hidden fields in the form. This way a bookmarklet will be
able to read the fields, and authentication can be done without trusting the javascript sent by the server.

I also organized urls.py

When upgrading the user from a non-srp account to an SRP account, the client must send the server the password. I wasn't happy about doing this
in plaintext, so I've incorporated slowAES on both the client and the server to encrypt the password before it is sent, using the key generated
in the first SRP transaction.

Significant cleanup to srp.js.

This adds upgrade functionality so that existing django apps can switch to SRP.

If a user exists in the auth table but not the srp table, the server sends back the algorithm and salt needed to hash the password. The hashed
password is used to authenticate the user.

After the server authenticates the user and the user verifies the identity of the server, the user sends the password in plaintext. The server
uses the plaintext password to calculate the verifier and stores. Finally, the client reinitiates the login process.

This update separates the register functionality from the login library. The login script is now .3 kb smaller, but there is a new 1.1 kb
register file. I think that registrations are rare enough relative to logins that this should be a worthwhile tradeoff. This also prepares a
framework for importing an update file, which will allow existing installations to upgrade from less secure authentication protocols, so some of
the overhead in srp.js that was added here will help reduce the size as we add the update functionality.

Changes were made to improve database efficiency and to use the django authentication backend framework.

Removed debugging line from srp.js