shinymanager

You can use external SQL databases (PostgreSQL, MySQL, MS SQL Server, etc.) via the DBI interface.

1. Configure: Edit a YAML configuration file (templates available in the package) to define your database connection.
2. Initialize: Use create_sql_db() with your credentials and the config path.
3. Implement: In the Shiny server, use check_credentials(db = "path/to/config.yml") inside secure_server().

library(shiny)
library(shinymanager)

# 1. Init the SQL Database (requires a .yml config file)
# Template: system.file("sql_config/pg_template.yml", package = "shinymanager")

credentials <- data.frame(
  user = c("shiny", "shinymanager"),
  password = c("azerty", "12345"),
  stringsAsFactors = FALSE
)

create_sql_db(
  credentials_data = credentials,
  config_path = "path/to/your_sql_configuration.yml"
)

# 2. Shiny UI
ui <- fluidPage(
  tags$h2("My secure application"),
  verbatimTextOutput("auth_output")
)
ui <- secure_app(ui, choose_language = TRUE)

# 3. Shiny Server
server <- function(input, output, session) {
  res_auth <- secure_server(
    check_credentials = check_credentials(db = "path/to/your_sql_configuration.yml")
  )
  
  output$auth_output <- renderPrint({
    reactiveValuesToList(res_auth)
  })
}

shinyApp(ui, server)

To secure a Shiny application, you must wrap your UI with secure_app() and initialize the authentication logic at the top of your server function using secure_server().

1. UI: Call secure_app(ui) at the end of your UI definition.
2. Server: Call secure_server() at the beginning of your server function. This function returns an authentication result object (res_auth) which contains user information and creates specific inputs like input$shinymanager_where and input$shinymanager_language.

ui <- fluidPage(
  # your ui code
)
secure_app(ui)

server <- function(input, output, session) {
  res_auth <- secure_server(
    check_credentials = check_credentials(credentials)
  )

  # Access user info
  output$auth_output <- renderPrint({
    reactiveValuesToList(res_auth)
  })

  # Access shinymanager inputs
  observe({
    print(input$shinymanager_where)
    print(input$shinymanager_language)
  })

  # Your existing server logic...
}

Using a SQLite database enables the built-in administration interface, allowing admins to manage users, reset passwords, and view connection logs. The database is encrypted using openssl and passwords are hashed with scrypt.

1. Initialize the database

Use create_db() to create the encrypted SQLite file. You can provide a data.frame of initial credentials. It is recommended to use the keyring package to manage the encryption passphrase securely.

2. Connect the app to the database

Pass the SQLite path and passphrase to check_credentials() within secure_server(). To enable the administration tab in the UI, set enable_admin = TRUE in secure_app().

library(keyring)

# 1. Setup credentials
credentials <- data.frame(
  user = c("shiny", "shinymanager"),
  password = c("azerty", "12345"),
  admin = c(FALSE, TRUE),
  stringsAsFactors = FALSE
)

# 2. Secure the passphrase in keyring
key_set("R-shinymanager-key", "your_secret_passphrase")

# 3. Create the database
create_db(
  credentials_data = credentials,
  sqlite_path = "path/to/database.sqlite",
  passphrase = key_get("R-shinymanager-key")
)

# 4. Use in Shiny
ui <- secure_app(ui, enable_admin = TRUE)

server <- function(input, output, session) {
  res_auth <- secure_server(
    check_credentials = check_credentials(
      "path/to/database.sqlite",
      passphrase = key_get("R-shinymanager-key")
    )
  )
  # ...
}

To set up a persistent authentication system, use create_db() to initialize a SQLite database. You must provide a data frame containing user credentials. Note that the password field in your input data frame will be automatically hashed by the function for security.

Required parameters for create_db():

• credentials_data: A data frame with columns user, password, and admin (logical).
• sqlite_path: The file path where the SQLite database will be created.
• passphrase: A string used for encryption (use a passphrase without keyring if not using a system keyring).

require(shinymanager)

credentials <- data.frame(
  user = c("shiny", "shinymanager"),
  password = c("shiny", "shinymanager"),
  # password will automatically be hashed
  admin = c(FALSE, TRUE), # utilisateurs avec droits d'admin ?
  stringsAsFactors = FALSE
)

create_db(
  credentials_data = credentials,
  sqlite_path = "database.sqlite", # elle sera crée
  passphrase = "passphrase_wihtout_keyring"
)

For persistent and secure storage, use an encrypted SQLite database. Credentials are protected with AES encryption (via openssl) and passwords are hashed using scrypt.

1. Initialize the database using create_db().
2. Wrap the UI with secure_app(ui, enable_admin = TRUE) to allow admin access.
3. Initialize the server using secure_server() passing the SQLite path and the passphrase.

library(keyring)
library(shinymanager)

# 1. Init DB using credentials data
credentials <- data.frame(
  user = c("shiny", "shinymanager"),
  password = c("azerty", "12345"),
  admin = c(FALSE, TRUE),
  stringsAsFactors = FALSE
)

# Set a key in keyring
key_set("R-shinymanager-key", "obiwankenobi")

# Create the database
create_db(
  credentials_data = credentials,
  sqlite_path = "path/to/database.sqlite",
  passphrase = key_get("R-shinymanager-key", "obiwankenobi")
)

# 2. UI Setup
ui <- secure_app(ui, enable_admin = TRUE)

# 3. Server Setup
server <- function(input, output, session) {
  res_auth <- secure_server(
    check_credentials = check_credentials(
        "path/to/database.sqlite",
        passphrase = key_get("R-shinymanager-key", "obiwankenobi")
    )
  )
  
  output$auth_output <- renderPrint({
    reactiveValuesToList(res_auth)
  })
  
  # your classic server logic
}

shinyApp(ui, server)