mailgun-js-boland breaks got, use new official mailgun.js module instead

[sal-limones]

HTTPS requests set "Host" header to "localhost" after server is running for some time

• Node.js version: v15.13.0
• OS & version: Ubuntu 20.04.2 LTS (5.4.0-66-generic)
• Got 11.8.2

Restarting node process temporary fixes the problem, but it always appears again. HTTP requests always work as intended even when HTTPS ones already stopped working.

Here is the dump of the request with the wrong "Host" header sent:

Request {                                                                                                                                                                                                     
  _readableState: ReadableState {                                                                                                                                                                             
    objectMode: false,                                                                                                                                                                                        
    highWaterMark: 0,                                                                                                                                                                                         
    buffer: BufferList { head: null, tail: null, length: 0 },                                                                                                                                                 
    length: 0,                                                                                                                                                                                                
    pipes: [],                                                                                                                                                                                                
    flowing: null,                                                                                                                                                                                            
    ended: false,                                                                                                                                                                                             
    endEmitted: false,                                                                                                                                                                                        
    reading: false,                                                           
    constructed: true,                                                        
    sync: true,                        
    needReadable: false,                                     
    emittedReadable: false,                                                   
    readableListening: false,                    
    resumeScheduled: false,
    errorEmitted: false,
    emitClose: true,                                                                                                                                                                                          
    autoDestroy: false,                                                                                                                                                                                       
    destroyed: false,                                                                                                                                                                                         
    errored: null,                                                                                                                                                                                            
    closed: false,                                                                                                                                                                                            
    closeEmitted: false,                                                                                                                                                                                      
    defaultEncoding: 'utf8',                                                                                                                                                                                  
    awaitDrainWriters: null,                                                                                                                                                                                  
    multiAwaitDrain: false,                                                                                                                                                                                   
    readingMore: false,                                                                                                                                                                                       
    decoder: null,                                                                                                                                                                                            
    encoding: null,                                                                                                                                                                                           
    [Symbol(kPaused)]: null                                                                                                                                                                                   
  },                                                                                                                                                                                                          
  _events: [Object: null prototype] {                                                                                                                                                                         
    pipe: [ [Function (anonymous)], [Function (anonymous)] ],                                                                                                                                                 
    unpipe: [Function (anonymous)],                                                                                                                                                                           
    response: [ [Function], [Function (anonymous)] ],                                                                                                                                                         
    error: [Function: bound onceWrapper] { listener: [Function: onError] },                                                                                                                                   
    retry: [Function: bound onceWrapper] { listener: [Function (anonymous)] },                                                                                                                                
    request: [Function (anonymous)],                                                                                                                                                                          
    redirect: [Function (anonymous)],                                                                                                                                                                         
    uploadProgress: [Function (anonymous)],                                                                                                                                                                   
    downloadProgress: [Function (anonymous)]                                                                                                                                                                  
  },                                                                                                                                                                                                          
  _eventsCount: 9,                                                                                                                                                                                            
  _maxListeners: undefined,                                                                                                                                                                                   
  _writableState: WritableState {                                                                                                                                                                             
    objectMode: false,                                                                                                                                                                                        
    highWaterMark: 0,                                                                                                                                                                                         
    finalCalled: true,                                                                                                                                                                                        
    needDrain: false,                                                                                                                                                                                         
    ending: true,                                                                                                                                                                                             
    ended: true,                                                                                                                                                                                              
    finished: false,                                                                                                                                                                                          
    destroyed: false,                                                                                                                                                                                         
    decodeStrings: true,                                                                                                                                                                                      
    defaultEncoding: 'utf8',                                                                                                                                                                                  
    length: 0,                                                                                                                                                                                                
    writing: false,                                                                                                                                                                                           
    corked: 0,                                                                                                                                                                                                
    sync: false,                                                                                                                                                                                              
    bufferProcessing: false,                                                                                                                                                                                  
    onwrite: [Function: bound onwrite],                                                                                                                                                                       
    writecb: null,                                                                                                                                                                                            
    writelen: 0,                                                                                                                                                                                              
    afterWriteTickInfo: null,                                                                                                                                                                                 
    buffered: [],                                                                                                                                                                                             
    bufferedIndex: 0,                                                                                                                                                                                         
    allBuffers: true,                                                                                                                                                                                         
    allNoop: true,                                                                                                                                                                                            
    pendingcb: 1,                                                                                                                                                                                             
    constructed: true,                                                                                                                                                                                        
    prefinished: false,                                                                                                                                                                                       
    errorEmitted: false,                                                      
    emitClose: true,                                                          
    autoDestroy: false,                
    errored: null,                                           
    closed: false,                                                            
    closeEmitted: false,                         
    [Symbol(kOnFinished)]: []                                      
  },                                                                          
  allowHalfOpen: true,
  requestInitialized: true,
  redirects: [],                                                                                                                                                                                              
  retryCount: 0,                                                                                                                                                                                              
  _progressCallbacks: [],                                                                                                                                                                                     
  write: [Function: onLockedWrite],                                                                                                                                                                           
  end: [Function: onLockedWrite],                                                                                                                                                                             
  options: {                                                                                                                                                                                                  
    method: 'POST',                                                                                                                                                                                           
    retry: {                                                                                                                                                                                                  
      limit: 0,                                                                                                                                                                                               
      methods: [Array],                                                                                                                                                                                       
      statusCodes: [Array],                                                                                                                                                                                   
      errorCodes: [Array],                                                                                                                                                                                    
      maxRetryAfter: Infinity,                                                                                                                                                                                
      calculateDelay: [Function: calculateDelay]                                                                                                                                                              
    },                                                                                                                                                                                                        
    headers: {                                                                                                                                                                                                
      'user-agent': 'got (https://github.com/sindresorhus/got)',                                                                                                                                              
      'content-type': 'application/x-www-form-urlencoded',                                                                                                                                                    
      'content-length': '156',                                                                                                                                                                                
      'accept-encoding': 'gzip, deflate, br'                                                                                                                                                                  
    },                                                                                                                                                                                                        
    hooks: {                                                                                                                                                                                                  
      beforeError: [Array],                                                                                                                                                                                   
      init: [],                                                                                                                                                                                               
      beforeRequest: [],                                                                                                                                                                                      
      beforeRedirect: [],                                                                                                                                                                                     
      beforeRetry: [],                                                                                                                                                                                        
      afterResponse: []                                                                                                                                                                                       
    },                                                                                                                                                                                                        
    cache: undefined,                                                                                                                                                                                         
    dnsCache: undefined,                                                                                                                                                                                      
    decompress: true,                                                                                                                                                                                         
    throwHttpErrors: true,                                                                                                                                                                                    
    followRedirect: true,                                                                                                                                                                                     
    isStream: false,                                                                                                                                                                                          
    responseType: 'text',                                                                                                                                                                                     
    resolveBodyOnly: true,                                                                                                                                                                                    
    maxRedirects: 10,                                                                                                                                                                                         
    prefixUrl: [Getter/Setter],                                                                                                                                                                               
    methodRewriting: true,                                                                                                                                                                                    
    ignoreInvalidCookies: false,                                                                                                                                                                              
    http2: false,                                                                                                                                                                                             
    allowGetBody: false,                                                                                                                                                                                      
    https: undefined,                                                                                                                                                                                         
    pagination: {                                                                                                                                                                                             
      transform: [Function: transform],                                                                                                                                                                       
      paginate: [Function: paginate],                                                                                                                                                                         
      filter: [Function: filter],                                                                                                                                                                             
      shouldContinue: [Function: shouldContinue],                                                                                                                                                             
      countLimit: Infinity,                                                                                                                                                                                   
      backoff: 0,                                                                                                                                                                                             
      requestLimit: 10000,                                                                                                                                                                                    
      stackAllItems: true                                                     
    },                                                                        
    parseJson: [Function: parseJson],  
    stringifyJson: [Function: stringifyJson],                
    cacheOptions: {},                                                         
    url: URL {                                   
      href: 'https://secure.2checkout.com/order/idn.php',          
      origin: 'https://secure.2checkout.com',                
      protocol: 'https:',        
      username: '',                             
      password: '',
      host: 'secure.2checkout.com',
      hostname: 'secure.2checkout.com',                                                                                                                                                                       
      port: '',                                                                                                                                                                                               
      pathname: '/order/idn.php',                                                                                                                                                                             
      search: '',                                                                                                                                                                                             
      searchParams: URLSearchParams {},                                                                                                                                                                       
      hash: ''                                                                                                                                                                                                
    },                                                                                                                                                                                                        
    username: '',                                                                                                                                                                                             
    password: '',                                                                                                                                                                                             
    shared: undefined,                                                                                                                                                                                        
    cacheHeuristic: undefined,                                                                                                                                                                                
    immutableMinTimeToLive: undefined,                                                                                                                                                                        
    ignoreCargoCult: undefined,                                                                                                                                                                               
    request: undefined,                                                                                                                                                                                       
    timeout: {},                                                                                                                                                                                              
    agent: undefined,                                                                                                                                                                                         
    [Symbol(isNormalizedAlready)]: true,                                                                                                                                                                      
    [Symbol(request)]: [Function (anonymous)]                                                                                                                                                                 
  },                                                                                                                                                                                                          
  requestUrl: 'https://secure.2checkout.com/order/idn.php',                                                                                                                                                   
  _cannotHaveBody: false,                                                                                                                                                                                     
  _noPipe: true,                                                                                                                                                                                              
  [Symbol(kCapture)]: false,                                                                                                                                                                                  
  [Symbol(downloadedSize)]: 0,                                                                                                                                                                                
  [Symbol(uploadedSize)]: 156,                                                                                                                                                                                
  [Symbol(serverResponsesPiped)]: Set(0) {},                                                                                                                                                                  
  [Symbol(stopReading)]: true,                                                                                                                                                                                
  [Symbol(triggerRead)]: false,                                                                                                                                                                               
  [Symbol(jobs)]: [],                                                                                                                                                                                         
  [Symbol(body)]: 'removedfor=test',                             
  [Symbol(bodySize)]: 156,                                                                                                                                                                                    
  [Symbol(cancelTimeouts)]: [Function: cancelTimeouts],                                                                                                                                                       
  [Symbol(unproxyEvents)]: [Function (anonymous)],                                                                                                                                                            
  [Symbol(request)]: <ref *1> ClientRequest {                                                                                                                                                                 
    _events: [Object: null prototype] {                                                                                                                                                                       
      abort: [Function],                                                                                                                                                                                      
      socket: [Function (anonymous)],                                                                                                                                                                         
      finish: [Array],                                                                                                                                                                                        
      response: [Array],                                                                                                                                                                                      
      close: [Function],                                                                                                                                                                                      
      connect: [Function (anonymous)],                                                                                                                                                                        
      continue: [Function (anonymous)],                                                                                                                                                                       
      information: [Function (anonymous)],                                                                                                                                                                    
      upgrade: [Function (anonymous)],                                                                                                                                                                        
      timeout: [Function (anonymous)]                                                                                                                                                                         
    },                                                                                                                                                                                                        
    _eventsCount: 10,                                                                                                                                                                                         
    _maxListeners: undefined,                                                                                                                                                                                 
    outputData: [],                                                                                                                                                                                           
    outputSize: 0,                                                                                                                                                                                            
    writable: true,                                                           
    destroyed: true,                                                          
    _last: true,                       
    chunkedEncoding: false,                                  
    shouldKeepAlive: false,                                                   
    _defaultKeepAlive: true,                     
    useChunkedEncodingByDefault: true,                             
    sendDate: false,                                         
    _removedConnection: false,   
    _removedContLen: false,                     
    _removedTE: false,                                                        
    _contentLength: null,            
    _hasBody: true,
    _trailer: '',
    finished: true,                                                                                                                                                                                           
    _headerSent: true,                                                                                                                                                                                        
    _closed: false,                                                                                                                                                                                           
    socket: TLSSocket {                                                                                                                                                                                       
      _tlsOptions: [Object],                                                                                                                                                                                  
      _secureEstablished: true,                                                                                                                                                                               
      _securePending: false,                                                                                                                                                                                  
      _newSessionPending: false,                                                                                                                                                                              
      _controlReleased: true,                                                                                                                                                                                 
      secureConnecting: true,                                                                                                                                                                                 
      _SNICallback: null,                                                                                                                                                                                     
      servername: 'localhost',                                                                                                                                                                                
      alpnProtocol: false,                                                                                                                                                                                    
      authorized: false,                                                                                                                                                                                      
      authorizationError: 'ERR_TLS_CERT_ALTNAME_INVALID',                                                                                                                                                     
      encrypted: true,                                                                                                                                                                                        
      _events: [Object: null prototype],                                                                                                                                                                      
      _eventsCount: 11,                                                                                                                                                                                       
      connecting: false,                                                                                                                                                                                      
      _hadError: true,                                                                                                                                                                                        
      _parent: null,                                                                                                                                                                                          
      _host: 'localhost',                                                                                                                                                                                     
      _readableState: [ReadableState],                                                                                                                                                                        
      _maxListeners: undefined,                                                                                                                                                                               
      _writableState: [WritableState],                                                                                                                                                                        
      allowHalfOpen: false,                                                                                                                                                                                   
      _sockname: null,                                                                                                                                                                                        
      _pendingData: null,                                                                                                                                                                                     
      _pendingEncoding: '',                                                                                                                                                                                   
      server: undefined,                                                                                                                                                                                      
      _server: null,                                                                                                                                                                                          
      ssl: null,                                                                                                                                                                                              
      _requestCert: true,                                                                                                                                                                                     
      _rejectUnauthorized: true,                                                                                                                                                                              
      parser: null,                                                                                                                                                                                           
      _httpMessage: [Circular *1],                                                                                                                                                                            
      [Symbol(res)]: [TLSWrap],                                                                                                                                                                               
      [Symbol(verified)]: false,                                                                                                                                                                              
      [Symbol(pendingSession)]: <Buffer 30 82 06 7e 02 01 01 02 02 03 03 04 02 c0 2f 04 20 87 a7 e1 18 17 b7 4c bd ca 57 c0 25 04 3c aa b8 84 a0 7c 69 5e 7e 04 96 fd 06 5c e8 08 31 a8 fb 04 ... 1616 more by
tes>,                                                                                                                                                                                                                                                          
      [Symbol(async_id_symbol)]: 178877,                                                                                                                                                                      
      [Symbol(kHandle)]: null,                                                                                                                                                                                
      [Symbol(kSetNoDelay)]: false,                                                                                                                                                                           
      [Symbol(lastWriteQueueSize)]: 372,                                                                                                                                                                      
      [Symbol(timeout)]: null,                                                                                                                                                                                
      [Symbol(kBuffer)]: null,                                                                                                                                                                                
      [Symbol(kBufferCb)]: null,                                                                                                                                                                              
      [Symbol(kBufferGen)]: null,                                                                                                                                                                             
      [Symbol(kCapture)]: false,                                              
      [Symbol(kBytesRead)]: 0,                                                
      [Symbol(kBytesWritten)]: 372,    
      [Symbol(connect-options)]: [Object]                    
    },                                                                        
    _header: 'POST / HTTP/1.1\r\n' +             
      'user-agent: got (https://github.com/sindresorhus/got)\r\n' +
      'content-type: application/x-www-form-urlencoded\r\n' +
      'content-length: 156\r\n' +
      'accept-encoding: gzip, deflate, br\r\n' +
      'Host: localhost\r\n' +                                                 
      'Connection: close\r\n' +      
      '\r\n',                                                                 
    _keepAliveTimeout: 0,                                                     
    _onPendingData: {},
    agent: Agent {
      _events: [Object: null prototype],                                                                                                                                                                      
      _eventsCount: 2,                                                                                                                                                                                        
      _maxListeners: undefined,                                                                                                                                                                               
      defaultPort: 443,                                                                                                                                                                                       
      protocol: 'https:',                                                                                                                                                                                     
      options: [Object],                                                                                                                                                                                      
      requests: {},                                                                                                                                                                                           
      sockets: [Object],                                                                                                                                                                                      
      freeSockets: {},                                                                                                                                                                                        
      keepAliveMsecs: 1000,                                                                                                                                                                                   
      keepAlive: false,                                                                                                                                                                                       
      maxSockets: Infinity,                                                                                                                                                                                   
      maxFreeSockets: 256,                                                                                                                                                                                    
      scheduling: 'lifo',                                                                                                                                                                                     
      maxTotalSockets: Infinity,                                                                                                                                                                              
      totalSocketCount: 1,                                                                                                                                                                                    
      maxCachedSessions: 100,                                                                                                                                                                                 
      _sessionCache: [Object],                                                                                                                                                                                
      [Symbol(kCapture)]: false                                                                                                                                                                               
    },                                                                                                                                                                                                        
    socketPath: undefined,                                                                                                                                                                                    
    method: 'POST',                                                                                                                                                                                           
    maxHeaderSize: undefined,                                                                                                                                                                                 
    insecureHTTPParser: undefined,                                                                                                                                                                            
    path: '/',                                                                                                                                                                                                
    _ended: false,                                                                                                                                                                                            
    res: null,                                                                                                                                                                                                
    aborted: false,                                                                                                                                                                                           
    timeoutCb: null,                                                                                                                                                                                          
    upgradeOrConnect: false,                                                                                                                                                                                  
    parser: null,                                                                                                                                                                                             
    maxHeadersCount: null,                                                                                                                                                                                    
    reusedSocket: false,                                                                                                                                                                                      
    host: 'localhost',                                                                                                                                                                                        
    protocol: 'https:',                                                                                                                                                                                       
    timings: {                                                                                                                                                                                                
      start: 1617365597895,                                                                                                                                                                                   
      socket: 1617365597896,                                                                                                                                                                                  
      lookup: 1617365597896,                                                                                                                                                                                  
      connect: 1617365597897,                                                                                                                                                                                 
      secureConnect: undefined,                                                                                                                                                                               
      upload: undefined,                                                                                                                                                                                      
      response: undefined,                                                                                                                                                                                    
      end: undefined,                                                                                                                                                                                         
      error: 1617365597903,                                                                                                                                                                                   
      abort: undefined,                                                                                                                                                                                       
      phases: [Object]                                                        
    },                                                                        
    emit: [Function: bound emit],      
    [Symbol(kCapture)]: false,                               
    [Symbol(kNeedDrain)]: false,                                              
    [Symbol(corked)]: 0,                         
    [Symbol(kOutHeaders)]: [Object: null prototype] {
      'user-agent': [Array],    
      'content-type': [Array],   
      'content-length': [Array],
      'accept-encoding': [Array],                                             
      host: [Array]                  
    },                                                                        
    [Symbol(reentry)]: true,                                                  
    [Symbol(kError)]: undefined     
  }                                                                           
}
RequestError: Hostname/IP does not match certificate's altnames: Host: localhost. is not in the cert's altnames: DNS:test.com
    at ClientRequest.<anonymous> (/var/www/test/node_modules/got/dist/source/core/index.js:956:111)
    at Object.onceWrapper (node:events:476:26)
    at ClientRequest.emit (node:events:381:22)
    at ClientRequest.origin.emit (/var/www/test/node_modules/@szmarczak/http-timer/dist/source/index.js:39:20)
    at TLSSocket.socketErrorListener (node:_http_client:469:9)
    at TLSSocket.emit (node:events:369:20)
    at emitErrorNT (node:internal/streams/destroy:188:8)                      
    at emitErrorCloseNT (node:internal/streams/destroy:153:3)                 
    at processTicksAndRejections (node:internal/process/task_queues:81:21)                                                                                                                                    
    at new NodeError (node:internal/errors:329:5)                                                                                                                                                             
    at Object.checkServerIdentity (node:tls:315:12)
    at TLSSocket.onConnectSecure (node:_tls_wrap:1541:27)
    at TLSSocket.emit (node:events:369:20)                                                                                                                                                                    
    at TLSSocket._finishInit (node:_tls_wrap:945:8)           
    at TLSWrap.ssl.onhandshakedone (node:_tls_wrap:719:12) { 
  code: 'ERR_TLS_CERT_ALTNAME_INVALID',                                       
  timings: {                                                                  
    start: 1617365597895,                                                  
    socket: 1617365597896,                                                                                                                                                                                    
    lookup: 1617365597896,                               
    connect: 1617365597897,                              
    secureConnect: undefined,                                                 
    upload: undefined,                                                        
    response: undefined,                                                      
    end: undefined,                    
    error: 1617365597903,                                                     
    abort: undefined,                                                         
    phases: {                                                                 
      wait: 1,                              
      dns: 0,                                                                 
      tcp: 1,                                                                 
      tls: undefined,   
      request: undefined,                                                                                                                                                                                     
      firstByte: undefined,
      download: undefined,                             
      total: 8                                    
    }                                                                         
  }                                                                           
}

[szmarczak]

Can you provide the code where you call got?

[sal-limones]

  const params = new URLSearchParams({ MERCHANT: code, ORDER_REF: data.ORDER_REF, ORDER_AMOUNT: data.ORDER_AMOUNT, ORDER_CURRENCY: data.ORDER_CURRENCY, IDN_DATE: date, ORDER_HASH: orderHash })                                                               
  let response                                                                                                                                                                                                                                                 
  try {                                                                                                                                                                                                                                                        
    response = await got.post('https://secure.2checkout.com/order/idn.php', { headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: params.toString(), resolveBodyOnly: true, retry: 0,                                                      
      hooks: {                                                                                                                                                                                                                                                 
        beforeError: [                                                                                                                                                                                                                                         
          error => {                                                                                                                                                                                                                                           
            const { request } = error                                                                                                                                                                                                                          
            console.log(request)                                                                                                                                                                                                                               
            return error                                                                                                                                                                                                                                       
          }                                                                                                                                                                                                                                                    
        ],                                                                                                                                                                                                                                                     
      }                                                                                                                                                                                                                                                        
    })                                                                                                                                                                                                                                                         
  } catch (error) {                                                                                                                                                                                                                                            
    console.log(error)                                                                                                                                                                                                                                         
  } 

[sal-limones]

Finally found the source of the problem:
mailgun/mailgun-js-boland#265

Since the mailgun-js-boland is already deprecated, just use the new official mailgun.js node module as a substitution.