Initial commit

.gitignore

+.DS_Store
+node_modules
+test.js

README.md

+# SMB2 Client for Node.js
+
+## Introduction
+
+This library is a simple implementation of SMB2 for Node.js. It allows you to access a SMB2 share as if you were using the native fs library.
+
+The development is still at an experimental stage and should not be yet considered for production environment.
+
+## Installation
+
+npm install smb2
+
+## Usage
+
+```javascript
+// load the library
+var SMB2 = require('smb2');
+
+// create an SMB2 instance
+var s = new SMB2({
+  share:'\\\\000.000.000.000\\c$'
+, domain:'DOMAIN'
+, username:'username'
+, password:'password!'
+});
+
+// negotiate the connection with the server
+s.connect(function(err){
+
+    // if an error happen => throw it
+    if(err) throw err;
+
+    // read the content of the folder
+    s.readDir('Windows\\System32', function(err, files){
+        
+        // if an error happen => throw it
+        if(err) throw err;
+        
+        // display content in the console
+        console.log(files.map(function(v){return v.Filename}));
+        
+        // close the connection
+        s.close();
+        
+    });
+
+});
+
+```
+
+## References
+
+    The[MS-SMB2]: Server Message Block (SMB) Protocol Versions 2 and 3
+    Copyright (C) 2014 Microsoft
+    http://msdn.microsoft.com/en-us/library/cc246482.aspx
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2013-2014 Benjamin Chelli <benjamin@chelli.net>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file

lib/message.js

+
+
+
+/*
+ * STATICS
+ */
+var messageId = 0;
+
+
+
+/*
+ * CONSTANTS
+ */
+const protocolId = new Buffer([0xFE, 'S'.charCodeAt(0), 'M'.charCodeAt(0), 'B'.charCodeAt(0)])
+
+    , processId = new Buffer([0xFF, 0xFE, 0x00, 0x00])
+
+    , headerTranslates = {
+        'Command': {
+          'NEGOTIATE': 0x0000
+        , 'SESSION_SETUP': 0x0001
+        , 'LOGOFF': 0x0002
+        , 'TREE_CONNECT': 0x0003
+        , 'TREE_DISCONNECT': 0x0004
+        , 'CREATE': 0x0005
+        , 'CLOSE': 0x0006
+        , 'FLUSH': 0x0007
+        , 'READ': 0x0008
+        , 'WRITE': 0x0009
+        , 'LOCK': 0x000A
+        , 'IOCTL': 0x000B
+        , 'CANCEL': 0x000C
+        , 'ECHO': 0x000D
+        , 'QUERY_DIRECTORY': 0x000E
+        , 'CHANGE_NOTIFY': 0x000F
+        , 'QUERY_INFO': 0x0010
+        , 'SET_INFO': 0x0011
+        , 'OPLOCK_BREAK': 0x0012
+        }
+      }
+
+    , flags = {
+        'SERVER_TO_REDIR': 0x00000001
+      , 'ASYNC_COMMAND': 0x00000002
+      , 'RELATED_OPERATIONS': 0x00000004
+      , 'SIGNED': 0x00000008
+      , 'DFS_OPERATIONS': 0x10000000
+      , 'REPLAY_OPERATION': 0x20000000
+      }
+
+    , headerLength = 64
+
+    , headerSync = [
+        ['ProtocolId',4,protocolId]
+      , ['StructureSize',2,headerLength]
+      , ['CreditCharge',2,0]
+      , ['Status',4,0]
+      , ['Command',2]
+      , ['Credit',2,126]
+      , ['Flags',4,0]
+      , ['NextCommand',4,0]
+      , ['MessageId',4]
+      , ['MessageIdHigh',4,0]
+      , ['ProcessId',4,processId]
+      , ['TreeId',4,0]
+      , ['SessionId',8,0]
+      , ['Signature',16,0]
+      ]
+
+    , headerASync = [
+        ['ProtocolId',4,protocolId]
+      , ['StructureSize',2,headerLength]
+      , ['CreditCharge',2,0]
+      , ['Status',4,0]
+      , ['Command',2]
+      , ['Credit',2,126]
+      , ['Flags',4,0]
+      , ['NextCommand',4,0]
+      , ['MessageId',4]
+      , ['MessageIdHigh',4,0]
+      , ['AsyncId',8]
+      , ['SessionId',8,0]
+      , ['Signature',16,0]
+      ]
+
+    ;
+
+/*
+ * CONSTRUCTOR
+ */
+var SMB2Message = module.exports = function(options){
+
+  // INIT HEADERS
+  this.headers = {};
+  if(options && options.headers){
+    this.setHeaders(options.headers);
+  }
+
+  // INIT REQUEST
+  this.request = {};
+  if(options && options.request){
+    this.setRequest(options.request);
+  }
+
+  // INIT RESPONSE
+  this.response = {};
+
+}
+
+var proto = SMB2Message.prototype = {};
+
+
+
+proto.setHeaders = function(obj){
+  for(var key in obj){
+    this.headers[key] = obj[key];
+  }
+  this.structure = require('./structures/'+this.headers['Command'].toLowerCase());
+}
+
+proto.getHeaders = function(){
+  return this.headers;
+}
+
+
+
+proto.setRequest = function(request){
+  this.request = request;
+}
+
+proto.getResponse = function(){
+  return this.response;
+}
+
+
+
+proto.getBuffer = function(){
+  var buffer = new Buffer(0xFFFF)
+    , length = 0
+    ;
+
+  // SET MESSAGE ID
+  if(!this.isMessageIdSetted){
+    this.isMessageIdSetted = true;
+    this.headers['MessageId'] = messageId++;
+  }
+
+  // HEADERS
+  length += writeHeaders(this, buffer);
+
+  // REQUEST
+  length += writeRequest(this, buffer, headerLength)
+
+  // extract the data
+  var output = new Buffer(length);
+  buffer.copy(output, 0, 0, length);
+  return output;
+}
+
+proto.parseBuffer = function(buffer){
+
+  // HEADERS
+  readHeaders(this, buffer)
+
+  // RESPONSE
+  readResponse(this, buffer, headerLength)
+
+}
+
+
+
+
+
+/*
+ * HELPERS
+ */
+function dataToBuffer(data, length) {
+
+  // buffers will be buffers
+  if(Buffer.isBuffer(data)){
+    return data;
+  }
+
+  // string to buffer
+  if(typeof data == 'string'){
+    return new Buffer(data);
+  }
+
+  // raw data to buffer
+  var result = new Buffer(length);
+  for(var i=0; i<length;i++){
+    result.writeUInt8(
+      0xFF & (data >> (i*8))
+    , i
+    );
+  }
+  return result;
+
+}
+function bufferToData(buffer) {
+
+  // not a buffer go away
+  if(!Buffer.isBuffer(buffer)){
+    return buffer;
+  }
+
+  // raw data to buffer
+  var result = 0;
+  for(var i=0; i<buffer.length;i++){
+    result += buffer.readUInt8(i) << (i*8);
+  }
+  return result;
+
+}
+function writeData(buffer, data, offset, length){
+  dataToBuffer(data, length).copy(buffer, offset, 0)
+}
+function readData(buffer, offset, length){
+  return buffer.slice(offset, offset+length);
+}
+function translate(key, value){
+  if(headerTranslates[key] && typeof headerTranslates[key][value] != 'undefined'){
+    return headerTranslates[key][value];
+  }
+  return value;
+}
+function unTranslate(key, value){
+  if(headerTranslates[key]){
+    for(var t in headerTranslates[key]){
+      if(headerTranslates[key][t] == value){
+        return t;
+      }
+    }
+  }
+  return null;
+}
+
+
+
+
+
+/*
+ * PRIVATE FUNCTIONS
+ */
+function readHeaders(message, buffer){
+  var header = message.isAsync ? headerASync : headerSync
+    , offset = 0
+    ;
+  for(var i in header){
+    var key = header[i][0]
+      , length = header[i][1]
+      ;
+    message.headers[key] = readData(
+      buffer
+    , offset
+    , length
+    );
+    if(length <= 8){
+      message.headers[key] = unTranslate(key, bufferToData(message.headers[key])) || message.headers[key];
+    }
+    offset += length;
+  }
+  message.structure = require('./structures/'+message.headers['Command'].toLowerCase());
+}
+
+
+function writeHeaders(message, buffer){
+  var header = message.isAsync ? headerASync : headerSync
+    , offset = 0
+    ;
+  for(var i in header){
+    var key = header[i][0]
+      , length = header[i][1]
+      , defaultValue = header[i][2] || 0
+      ;
+    writeData(
+      buffer
+    , translate(key, message.headers[key] || defaultValue)
+    , offset
+    , length
+    );
+    offset += length;
+  }
+  return offset;
+}
+
+
+
+
+
+function readResponse(message, buffer, offset){
+  for(var i in message.structure.response){
+    var key = message.structure.response[i][0]
+      , length = message.structure.response[i][1] || 1
+      ;
+    if(typeof length == 'string'){
+      length = bufferToData(message.response[length]);
+    }
+    message.response[key] = readData(buffer, offset, length);
+    offset += length;
+  }
+}
+
+
+function writeRequest(message, buffer, offset){
+  var initOffset = offset
+    , needsRewrite = false
+    , tmpBuffer = new Buffer(buffer.length)
+    ;
+  offset = 0;
+  for(var i in message.structure.request){
+    var key = message.structure.request[i][0]
+      , length = message.structure.request[i][1] || 1
+      , defaultValue = message.structure.request[i][2] || 0
+      ;
+    if(typeof length == 'string'){
+      message.request[key] = message.request[key] || '';
+      if(message.request[length] != message.request[key].length) {
+        message.request[length] = message.request[key].length;
+        needsRewrite = true;
+      }
+      length = message.request[key].length;
+    } else {
+      message.request[key] = message.request[key] || defaultValue;
+    }
+    writeData(
+      tmpBuffer
+    , message.request[key]
+    , offset
+    , length
+    );
+    offset += length;
+  }
+  if(needsRewrite){
+    writeRequest(message, tmpBuffer, 0);
+  }
+  tmpBuffer.copy(buffer, initOffset, 0, offset);
+  return offset;
+}

lib/messages/close.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection, params){
+    return new SMB2Message({
+      headers:{
+        'Command':'CLOSE'
+      , 'SessionId':connection.SessionId
+      , 'TreeId':connection.TreeId
+      }
+    , request:{
+        'FileId':params.FileId
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_SUCCESS'){
+        cb && cb(null);
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/create.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection, params){
+    var buffer = new Buffer(params.path, 'ucs2');
+    return new SMB2Message({
+      headers:{
+        'Command':'CREATE'
+      , 'SessionId':connection.SessionId
+      , 'TreeId':connection.TreeId
+      }
+    , request:{
+        'Buffer':buffer
+      , 'DesiredAccess':0x001701DF
+      , 'FileAttributes':0x00000080
+      , 'ShareAccess':0x00000000
+      , 'CreateDisposition':0x00000005
+      , 'CreateOptions':0x00000044
+      , 'NameOffset':0x0078
+      , 'CreateContextsOffset':0x007A+buffer.length
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_SUCCESS'){
+        cb && cb(null, response.getResponse());
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/negotiate.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection){
+    return new SMB2Message({
+      headers:{
+        'Command':'NEGOTIATE'
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_SUCCESS'){
+        cb && cb(null);
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/open.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection, params){
+    var buffer = new Buffer(params.path, 'ucs2');
+    return new SMB2Message({
+      headers:{
+        'Command':'CREATE'
+      , 'SessionId':connection.SessionId
+      , 'TreeId':connection.TreeId
+      }
+    , request:{
+        'Buffer':buffer
+      , 'NameOffset':0x0078
+      , 'CreateContextsOffset':0x007A+buffer.length
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_SUCCESS'){
+        cb && cb(null, response.getResponse());
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/query_directory.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection, params){
+    return new SMB2Message({
+      headers:{
+        'Command':'QUERY_DIRECTORY'
+      , 'SessionId':connection.SessionId
+      , 'TreeId':connection.TreeId
+      }
+    , request:{
+        'FileId':params.FileId
+      , 'Buffer':new Buffer('*', 'ucs2')
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_SUCCESS'){
+        cb && cb(
+          null
+        , parseFiles(response.getResponse().Buffer)
+        );
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+
+
+
+
+
+
+/*
+ * HELPERS
+ */
+function parseFiles(buffer){
+  var files = []
+    , offset = 0
+    , nextFileOffset = -1
+    ;
+  while(nextFileOffset!=0){
+    // extract next file offset
+    nextFileOffset = buffer.readUInt32LE(offset);
+    // extract the file
+    files.push(
+      parseFile(
+        buffer.slice(offset+4, nextFileOffset ? offset+nextFileOffset : buffer.length)
+      )
+    );
+    // move to nex file
+    offset += nextFileOffset;
+  }
+  return files;
+}
+
+function parseFile(buffer){
+  var file = {}
+    , offset = 0
+    ;
+
+  // index
+  file.Index = buffer.readUInt32LE(offset);
+  offset+=4;
+
+  // CreationTime
+  file.CreationTime = buffer.slice(offset, offset+8);
+  offset+=8;
+
+  // LastAccessTime
+  file.LastAccessTime = buffer.slice(offset, offset+8);
+  offset+=8;
+
+  // LastWriteTime
+  file.LastWriteTime = buffer.slice(offset, offset+8);
+  offset+=8;
+
+  // ChangeTime
+  file.ChangeTime = buffer.slice(offset, offset+8);
+  offset+=8;
+
+  // EndofFile
+  file.EndofFile = buffer.slice(offset, offset+8);
+  offset+=8;
+
+  // AllocationSize
+  file.AllocationSize = buffer.slice(offset, offset+8);
+  offset+=8;
+
+  // FileAttributes
+  file.FileAttributes = buffer.readUInt32LE(offset);
+  offset+=4;
+
+  // FilenameLength
+  file.FilenameLength = buffer.readUInt32LE(offset);
+  offset+=4;
+
+  // EASize
+  file.EASize = buffer.readUInt32LE(offset);
+  offset+=4;
+
+  // ShortNameLength
+  file.ShortNameLength = buffer.readUInt8(offset);
+  offset+=1;
+
+  // FileId
+  file.FileId = buffer.slice(offset, offset+8);
+  offset+=8;
+
+  // Reserved
+  offset+=27;
+
+  // Filename
+  file.Filename = buffer.slice(offset, offset+file.FilenameLength).toString('ucs2');
+  offset+=file.FilenameLength;
+
+  return file;
+}
\ No newline at end of file

lib/messages/read.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection, file){
+    return new SMB2Message({
+      headers:{
+        'Command':'READ'
+      , 'SessionId':connection.SessionId
+      , 'TreeId':connection.TreeId
+      }
+    , request:{
+        'FileId':file.FileId
+      , 'Length':file.Length
+      , 'Offset':file.Offset
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if (err.code == 'STATUS_SUCCESS'){
+        cb && cb(null, response.getResponse().Buffer);
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/session_setup_step1.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  , ntlm = require('ntlm')
+  ;
+
+
+module.exports = {
+  generate:function(connection){
+    return new SMB2Message({
+      headers:{
+        'Command':'SESSION_SETUP'
+      }
+    , request:{
+        'Buffer':ntlm.encodeType1(
+          connection.ip
+        , connection.domain
+        )
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_MORE_PROCESSING_REQUIRED'){
+        connection.SessionId = h.SessionId;
+        connection.nonce = ntlm.decodeType2(response.getResponse().Buffer);
+        cb && cb(null);
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/session_setup_step2.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  , ntlm = require('ntlm')
+  ;
+
+
+module.exports = {
+  generate:function(connection){
+    return new SMB2Message({
+      headers:{
+        'Command':'SESSION_SETUP'
+      , 'SessionId':connection.SessionId
+      }
+    , request:{
+        'Buffer':ntlm.encodeType3(
+          connection.username
+        , connection.ip
+        , connection.domain
+        , connection.nonce
+        , connection.password
+        )
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(       err.code == 'STATUS_LOGON_FAILURE'){
+        cb && cb(new Error('Login attempt fail'));
+      } else if(err.code == 'STATUS_SUCCESS'){
+        cb && cb(null);
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/set_info.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+var fileInfoClasses = {
+  'FileAllocationInformation': 19
+, 'FileBasicInformation': 4
+, 'FileDispositionInformation': 13
+, 'FileEndOfFileInformation': 20
+, 'FileFullEaInformation': 15
+, 'FileLinkInformation': 11
+, 'FileModeInformation': 16
+, 'FilePipeInformation': 23
+, 'FilePositionInformation': 14
+, 'FileRenameInformation': 10
+, 'FileShortNameInformation': 40
+, 'FileValidDataLengthInformation': 39
+};
+
+module.exports = {
+  generate:function(connection, params){
+    return new SMB2Message({
+      headers:{
+        'Command':'SET_INFO'
+      , 'SessionId':connection.SessionId
+      , 'TreeId':connection.TreeId
+      }
+    , request:{
+        'FileInfoClass':fileInfoClasses[params.FileInfoClass]
+      , 'FileId':params.FileId
+      , 'Buffer':params.Buffer
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_SUCCESS'){
+        cb && cb(null, response.getResponse());
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/tree_connect.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection){
+    return new SMB2Message({
+      headers:{
+        'Command':'TREE_CONNECT'
+      , 'SessionId':connection.SessionId
+      }
+    , request:{
+        'Buffer':new Buffer(connection.fullPath, 'ucs2')
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if(err.code == 'STATUS_SUCCESS'){
+        connection.TreeId = h.TreeId;
+        cb && cb(null);
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/messages/write.js

+
+
+var SMB2Message = require('../message')
+  , MsErref = require('../tools/ms_erref')
+  , bigint = require('../tools/bigint')
+  ;
+
+
+module.exports = {
+  generate:function(connection, params){
+    return new SMB2Message({
+      headers:{
+        'Command':'WRITE'
+      , 'SessionId':connection.SessionId
+      , 'TreeId':connection.TreeId
+      }
+    , request:{
+        'FileId':params.FileId
+      , 'Offset':params.Offset
+      , 'Buffer':params.Buffer
+      }
+    })
+  }
+, parse:function(connection, cb){
+    return function(response){
+      var h = response.getHeaders()
+        , err = MsErref.getStatus(bigint.fromBuffer(h.Status).toNumber())
+        ;
+      if (err.code == 'STATUS_SUCCESS'){
+        cb && cb(null, response.getResponse().Buffer);
+      } else {
+        cb && cb(new Error(MsErref.getErrorMessage(err)));
+      }
+    }
+  }
+}
+

lib/structures/close.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 24]
+  , ['Flags', 2, 0]
+  , ['Reserved', 4, 0]
+  , ['FileId', 16]
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  , ['Flags', 2]
+  , ['Reserved', 4]
+  , ['CreationTime', 8]
+  , ['LastAccessTime', 8]
+  , ['LastWriteTime', 8]
+  , ['ChangeTime', 8]
+  , ['AllocationSize', 8]
+  , ['EndofFile', 8]
+  , ['FileAttributes', 4]
+  ]
+
+}
+

lib/structures/create.js

+
+
+module.exports = {
+
+  request:[
+
+    ['StructureSize', 2, 57]
+  , ['SecurityFlags', 1, 0]
+  , ['RequestedOplockLevel', 1, 0]
+  , ['ImpersonationLevel', 4, 0x00000002]
+  , ['SmbCreateFlags', 8, 0]
+  , ['Reserved', 8, 0]
+  , ['DesiredAccess',     4, 0x00100081]
+  , ['FileAttributes',    4, 0x00000000]
+  , ['ShareAccess',       4, 0x00000007]
+  , ['CreateDisposition', 4, 0x00000001]
+  , ['CreateOptions',     4, 0x00000020]
+  , ['NameOffset', 2]
+  , ['NameLength', 2]
+  , ['CreateContextsOffset', 4]
+  , ['CreateContextsLength', 4]
+  , ['Buffer', 'NameLength']
+  , ['Reserved2', 2, 0x4200]
+  , ['CreateContexts', 'CreateContextsLength', '']
+
+  ]
+
+, response:[
+
+    ['StructureSize', 2]
+  , ['OplockLevel', 1]
+  , ['Flags', 1]
+  , ['CreateAction', 4]
+  , ['CreationTime', 8]
+  , ['LastAccessTime', 8]
+  , ['LastWriteTime', 8]
+  , ['ChangeTime', 8]
+  , ['AllocationSize', 8]
+  , ['EndofFile', 8]
+  , ['FileAttributes', 4]
+  , ['Reserved2', 4]
+  , ['FileId', 16]
+  , ['CreateContextsOffset', 4]
+  , ['CreateContextsLength', 4]
+  , ['Buffer', 'CreateContextsLength']
+
+  ]
+
+}
+

lib/structures/negotiate.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 36]
+  , ['DialectCount', 2, 2]
+  , ['SecurityMode', 2, 1]
+  , ['Reserved', 2, 0]
+  , ['Capabilities', 4, 0]
+  , ['ClientGuid', 16, 0]
+  , ['ClientStartTime', 8, 0]
+  , ['Dialects', 4, new Buffer([0x02,0x02,0x10,0x02])]
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  , ['SecurityMode', 2]
+  , ['DialectRevision', 2]
+  , ['Reserved', 2]
+  , ['ServerGuid', 16]
+  , ['Capabilities', 4]
+  , ['MaxTransactSize', 4]
+  , ['MaxReadSize', 4]
+  , ['MaxWriteSize', 4]
+  , ['SystemTime', 8]
+  , ['ServerStartTime', 8]
+  , ['SecurityBufferOffset', 2]
+  , ['SecurityBufferLength', 2]
+  , ['Reserved2', 4]
+  , ['Buffer', 'SecurityBufferLength']
+  ]
+
+}
+

lib/structures/query_directory.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 33]
+  , ['FileInformationClass', 1, 0x25] // FileBothDirectoryInformation plus volume file ID about a file or directory.
+  , ['Flags', 1, 0]
+  , ['FileIndex', 4, 0]
+  , ['FileId', 16]
+  , ['FileNameOffset', 2, 96]
+  , ['FileNameLength', 2]
+  , ['OutputBufferLength', 4, 0x00010000]
+  , ['Buffer', 'FileNameLength']
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  , ['OutputBufferOffset', 2]
+  , ['OutputBufferLength', 4]
+  , ['Buffer', 'OutputBufferLength']
+  ]
+
+}
+

lib/structures/read.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 49]
+  , ['Padding', 1, 0x50]
+  , ['Flags', 1, 0]
+  , ['Length', 4]
+  , ['Offset', 8]
+  , ['FileId', 16]
+  , ['MinimumCount', 4, 0]
+  , ['Channel', 4, 0]
+  , ['RemainingBytes', 4, 0]
+  , ['ReadChannelInfoOffset', 2, 0]
+  , ['ReadChannelInfoLength', 2, 0]
+  , ['Buffer', 1, 0]
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  , ['DataOffset', 1]
+  , ['Reserved', 1]
+  , ['DataLength', 4]
+  , ['DataRemaining', 4]
+  , ['Reserved2', 4]
+  , ['Buffer', 'DataLength']
+  ]
+
+}
+

lib/structures/session_setup.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 25]
+  , ['Flags', 1, 0]
+  , ['SecurityMode', 1, 1]
+  , ['Capabilities', 4, 1]
+  , ['Channel', 4, 0]
+  , ['SecurityBufferOffset', 2, 88]
+  , ['SecurityBufferLength', 2]
+  , ['PreviousSessionId', 8, 0]
+  , ['Buffer','SecurityBufferLength']
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  , ['SessionFlags', 2]
+  , ['SecurityBufferOffset', 2]
+  , ['SecurityBufferLength', 2]
+  , ['Buffer', 'SecurityBufferLength']
+  ]
+
+}
+

lib/structures/set_info.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 33]
+  , ['InfoType', 1, 1]
+  , ['FileInfoClass', 1]
+  , ['BufferLength', 4]
+  , ['BufferOffset', 2, 0x0060]
+  , ['Reserved', 2, 0]
+  , ['AdditionalInformation', 4, 0]
+  , ['FileId', 16]
+  , ['Buffer','BufferLength']
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  ]
+
+}
+

lib/structures/tree_connect.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 9]
+  , ['Reserved', 2, 0]
+  , ['PathOffset', 2, 72]
+  , ['PathLength', 2]
+  , ['Buffer', 'PathLength']
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  , ['ShareType', 1]
+  , ['Reserved', 1]
+  , ['ShareFlags', 4]
+  , ['Capabilities', 4]
+  , ['MaximalAccess', 4]
+  ]
+
+}
+

lib/structures/write.js

+
+
+module.exports = {
+
+  request:[
+    ['StructureSize', 2, 49]
+  , ['DataOffset', 2, 0x70]
+  , ['Length', 4, 0]
+  , ['Offset', 8]
+  , ['FileId', 16]
+  , ['Channel', 4, 0]
+  , ['RemainingBytes', 4, 0]
+  , ['WriteChannelInfoOffset', 2, 0]
+  , ['WriteChannelInfoLength', 2, 0]
+  , ['Flags', 4, 0]
+  , ['Buffer', 'Length']
+  ]
+
+, response:[
+    ['StructureSize', 2]
+  , ['Reserved', 2]
+  , ['Count', 4]
+  , ['Remaining', 4]
+  , ['WriteChannelInfoOffset', 2]
+  , ['WriteChannelInfoLength', 2]
+  ]
+
+}
+

lib/tools/bigint.js

+
+var BigInt = module.exports = function(n, v){
+
+  if(BigInt.isBigInt(n)){
+
+    this.buffer = new Buffer(n.buffer.length);
+    n.buffer.copy(this.buffer, 0);
+    this.sign = n.sign;
+
+  } else {
+
+    this.buffer = new Buffer(n);
+    this.buffer.fill(0);
+    this.sign = 1;
+
+    v = v || 0;
+
+    if(v != 0){
+
+      if(v<0) {
+        this.sign = -1;
+        v = -v;
+      }
+
+      v = v.toString(16);
+
+      var size = Math.ceil(v.length/2)
+        , carry = size*2 - v.length
+        ;
+
+      for(var i=0; i<size; i++) {
+        var start = (size - i - 1) * 2 - carry;
+        this.buffer.writeUInt8(
+          parseInt( start == -1 ? v.substr(0,1) : v.substr(start, 2), 16)
+        , i
+        );
+      }
+
+    }
+
+  }
+
+}
+
+
+/*
+ * STATICS
+ */
+BigInt.isBigInt = function(v){
+  return v && v.buffer && Buffer.isBuffer(v.buffer);
+}
+
+BigInt.toBigInt = function(n, v){
+  return new BigInt(n, v);
+}
+
+BigInt.fromBuffer = function(b, sign){
+  sign = typeof sign == 'undefined' ? 1 : sign;
+  var bi = new BigInt(0);
+  bi.sign = sign;
+  bi.buffer = b;
+  return bi;
+}
+
+
+/*
+ * ADD / SUB
+ */
+BigInt.prototype.add = function(v){
+
+  if(!BigInt.isBigInt(v)) {
+    v = BigInt.toBigInt(this.buffer.length, v);
+  }
+
+  if(this.sign != v.sign){
+    return this.neg().sub(v);
+  }
+
+  var carry = 0
+    , n = Math.max(v.buffer.length, this.buffer.length)
+    , result = new BigInt(n);
+    ;
+
+  for(var i=0;i<n;i++){
+    var r = ( i<this.buffer.length ? this.buffer.readUInt8(i) : 0 )
+          + ( i<v.buffer.length    ? v.buffer.readUInt8(i)    : 0 )
+          + carry
+          ;
+    result.buffer.writeUInt8(r & 0xFF, i);
+    carry = r >> 8;
+  }
+
+  result.sign = this.sign;
+  
+  return result;
+
+}
+
+BigInt.prototype.neg = function(v){
+  var result = new BigInt(this);
+  result.sign *= -1;
+  return result;
+}
+
+BigInt.prototype.abs = function(v){
+  var result = new BigInt(this);
+  result.sign = 1;
+  return result;
+}
+
+BigInt.prototype.sub = function(v){
+
+  if(!BigInt.isBigInt(v)) {
+    v = BigInt.toBigInt(this.buffer.length, v);
+  }
+
+  if(this.sign != v.sign) {
+    return this.add(v.neg());
+  }
+
+  var carry = 0
+    , a = new BigInt(this)
+    , b = new BigInt(v)
+    , n = Math.max(a.buffer.length, b.buffer.length)
+    , result = new BigInt(n)
+    , sign = this.sign
+    ;
+
+  if(a.abs().lt(b.abs())){
+    var t = a;
+    a = b;
+    b = t;
+    sign *= -1;
+  }
+
+  for(var i=0; i<n; i++){
+    var va = ( i<a.buffer.length ? a.buffer.readUInt8(i) : 0 )
+      , vb = ( i<b.buffer.length ? b.buffer.readUInt8(i) : 0 )
+      , c = 0
+      , r = va-vb-carry
+      ;
+
+    while(r<0){
+      r+=0xFF;
+      c--;
+    }
+
+    result.buffer.writeUInt8(r & 0xFF, i);
+    carry = (r >> 8) + c;
+  }
+
+  result.sign = sign;
+
+  return result;
+
+}
+
+
+/*
+ * EXPORTS
+ */
+BigInt.prototype.toBuffer = function(){ return this.buffer }
+
+BigInt.prototype.toNumber = function(){
+
+  var b = new Buffer(this.buffer.length);
+
+  for(var i=0; i<this.buffer.length; i++){
+    b.writeUInt8(this.buffer.readUInt8(this.buffer.length - i - 1), i);
+  }
+
+  return parseInt(b.toString('hex'), 16);
+
+}
+
+
+/*
+ * COMPARE
+ */
+BigInt.prototype.compare = function(v){
+
+  if(!BigInt.isBigInt(v)) {
+    v = BigInt.toBigInt(v, this.buffer.length);
+  }
+
+  var n = Math.max(v.buffer.length, this.buffer.length);
+
+  if(this.sign > v.sign) return 1;
+  if(this.sign < v.sign) return -1;
+
+  for(var i=n-1;i>=0;i--){
+    var a = ( i<this.buffer.length ? this.buffer.readUInt8(i) : 0 )
+      , b = ( i<v.buffer.length    ? v.buffer.readUInt8(i)    : 0 )
+      ;
+    if(a!=b){
+      return a > b ? this.sign : -this.sign;
+    }
+  }
+
+  return 0;
+
+}
+
+BigInt.prototype.lt = function(v){
+  return this.compare(v) < 0;
+}
+
+BigInt.prototype.le = function(v){
+  return this.compare(v) <= 0;
+}
+
+BigInt.prototype.gt = function(v){
+  return this.compare(v) > 0;
+}
+
+BigInt.prototype.ge = function(v){
+  return this.compare(v) >= 0;
+}
+
+
+
+

package.json

+{
+
+  "name":"SMB2"
+, "description":"SMB2 Client"
+, "homepage": "https://github.com/bchelli/node-smb2"
+
+, "version":"0.1.0"
+
+, "engines": [
+    "node"
+  ]
+
+, "author":{
+    "name": "Benjamin Chelli"
+  , "email": "benjamin@chelli.net"
+  , "url": "https://github.com/bchelli"
+  }
+
+, "main":"lib/smb2.js"
+
+, "repository": {
+    "type": "git"
+  , "url": "https://github.com/bchelli/node-smb2"
+  }
+
+, "dependencies": {
+    "ntlm": "~0.1.1"
+  }
+
+, "keywords": [
+    "SMB"
+  , "SMB2"
+  , "SMB3"
+  , "NTLM"
+  , "CIFS"
+  , "Samba"
+  ],
+
+}