const secret = "our super hyperdrive secret" + new Date();
return CryptoJS.HmacSHA512(token, secret);
}
function JWT(pl_user, pl_pass){
this.header = new Header("jwt", "HS512");
this.payload = new Payload(pl_user, pl_pass.hashCode());
let token = tob64(this.header) + "." + tob64(this.payload);
let signature = new Signature("token");
this.signedToken = token + "." + signature;
}
function add_token(token, user) {
for (let i = 0; i < valid_tokens.length; i++) {
if(Object.keys(valid_tokens[i])[0] == token){
valid_tokens.splice(i, 1);
console.log("Unable to add token. (token already present)");
break;
}
}
let obj = {}; obj[token.toString()] = user;
valid_tokens.push(obj);
console.log(valid_tokens)
console.log("Successfully added token.");
Le retour de cette route est un objet JSON formé de cette manière :
```json
{
"route":"/login",
"resCode":0,
"signedToken":jwt.signedToken,
"comment":`Passwordforuser'${user}'true.`
}
```
function remove_token(token) {
### /logout
Logout permet de supprimer un token lorsqu'un utilisateur se deconnecte.
for (let i = 0; i < valid_tokens.length; i++) {
Param :
if(Object.keys(valid_tokens[i])[0] == token){
- Token : Token de l'utilisateur a déconnecter
valid_tokens.splice(i, 1);
### /register
console.log("Successfully removed token from valid_tokens.");
Cette route permet d'inscrire un utilisateur au service de l'hyperdrive
return true;
Paramètres :
}
- pseudo : Pseudo du nouvel utilisateur
- password : Mot de passe du nouvel utilisateur
}
### /share/:file_id/:to_user
Cette route permet de partager un fichier avec un utilisateur
Paramètres :
console.log("Unable to remove token from valid_tokens. (Token not present)");
- token : Il s'agit du token de l'utilisateur qui souhaite partage un fichier
- file_id : Il s'agit de l'id du fichier à partager
- to_user : Il s'agit de la personne à qui on souhaite partager le fichier
### /upload
Cette fonction permet d'uploader un fichier dans un path.
Paramètre :
- token : Token d'authentification de l'utilisateur.
- file_name : Il s'agit du nom du fichier.
}
### /download/:file_id
Cette fonction permet de télécharger un fichier.
Paramètre :
// verify the token
- file_id : Id du fichier que l'on souhaite télécharger.
- token : Token d'authentification de l'utilisateur.
// return : user if exist
### /change-path*
function verify_token(token) {
Cette fonction permet d'afficher le contenu d'un dossier.
for (let i = 0; i < valid_tokens.length; i++) {
Paramètres :
if(Object.keys(valid_tokens[i])[0] == token)
- token : Token d'authentification de l'utilisateur.
- path : Il s'agit du dossier dont le contenu doit être affiché.
return valid_tokens[i][token];
Retour :
}
Cette route retour un tableau d'objet JSON. Chaque object est soit un dossier, soit un fichier
return false;
Voici l'exemple d'un objet fichier. Cet objet se trouve dans un array
```json
{
"paths":"/a",
"login":"a",
"parent":null,
"file_id":"ab",
"file_name":"deux"
}
```
Voici l'exemple d'un objet dossier. Cet objet se trouve dans un array
///// End JWT part /////
app.get('/', (req, res) => {
res.sendFile(__dirname + '/front/index.html');
});
/* Login
\* param : pseudo
\* param : password
*/
// resCode : [ 0: User now logged in, 1: False password, 2: Invalid username, 3: Empty user or pass ]
app.get('/login', (req, res) => {
const user = req.query['user'];
const pass = req.query['pass'];
sql.userExist(user, pass, (element) => {
if (element)
check_login(user, pass, element, res);
});
});
function check_login(user, pass, userObject, res) {
if (!user || !pass) {
res.send({
"route": "/login",
"resCode": 4,
"comment": "Please enter a username and a password."
})
}
else{
if (userObject){
if (userObject.passwd == pass.hashCode()) {
let jwt = new JWT(user, pass);
res.send({
"route": "/login",
"resCode": 0,
"signedToken": jwt.signedToken,
"comment": `Password for user '${ user }' true.`
})
add_token(jwt.signedToken, user);
}
else {
res.send({
"route": "/login",
"resCode": 1,
"comment": `Password for user '${ user }' false.`
})
}
}
else {
res.send({
"route": "/login",
"resCode": 2,
"comment": `Username '${ user }' don't exist.`
})
}
}
```json
{
"paths":"/a/coucou",
"login":"a",
"parent":"/a",
"file_id":null,
"file_name":null
}
```
Un dossier possède un parent, car il se trouve dans un dossier. Dans le cas du dossier, le champ *path* indique la ou se trouve le fichier ainsi que son nom. Le dernier élément est le nom, tandis que tout ce qui se trouve avant est la ou est stocké le fichier.
A l'inverse, un fichier se trouve dans un dossier, il a donc un *path*. Il est certe enfant d'un dossier, mais la seule information de ou il se trouve nous suffit.
// resCode : [ 0: Token is valid, 1: Token is not valid, 3: Empty token ]
app.get('/testmytoken', (req, res) => {
let token = req.query['token'];
### /create-path*
if (!token) {
Cette fonction permet de créer un dossier à un endroit spécifique.
res.send(`Request for an upload (${req.query['file']})`)
});
app.get('/download/:file_id', (req, res) => {
let token = req.query["token"]
let file_id = req.params["file_id"]
let user = verify_token(token);
if (user){
sql.verifyFileID(user, file_id, (filename) => {
console.log(filename)
if (filename){
res.download("files/" + file_id, filename);
}
else{
res.send("Can't download (not your file).")
}
})
}
else{
res.send("Can't download (please be connected).")
}
})
/**
\* This function return the content of a new path
\* param
*/
app.get('/change-path*', (req, res) => {
let path = req.params['0'].split("/");
path.pop();
path = path.join("/");
let tok = req.params['0'].split("/").pop();
let name = verify_token(tok);
if (name) {
let content = sql.changeDirectory(name, path,
(content) => {
res.send(content);
Paramètres :
});
}
})
### /get-info
La route get-info nous permet de récupérer les informations d'un fichier.
Paramètres :
app.get('/create-path*', (req, res) =>
- file_id : Id du fichier dont on souhaite avoir les informations.
- token : Il s'agit du token d'authentification.
### /get-info
### /show-shared-file
La route get-info nous permet de récupérer les informations d'un fichier
Cette route permet de récupérer tous les fichiers partagé avec un utilisateur.
Paramètres :
- file_id : Id du fichier dont on souhaite avoir les informations
- token : Il s'agit du token d'authentification
- token : Le token nous permet de récupérer l'id de l'utilisateur.
### /show-shared-file
Retour :
La réponse est un tableau d'objet JSON. Chaque objet contient ces informations :
```json
```
## Conclusion
\- Une conclusion
\ No newline at end of file
Lors du développement de ce drive, nous avons pu utiliser des technologies nouvelles ainsi qu'un manière intéressante de dévelloper. La programmation asynchrone fut difficile à prendre en main, mais nous y somme arrivé.
