text:
#include <stdio.h>              /* logw printf(), fscanf(), fopen(), fclose() */
#include <stdlib.h>             /* logw exit() */

int main()
{
    struct passenger
{
 char passengerName[40];
 unsigned short int passengerPhone[10];
 unsigned int passengerSeat;
};
   FILE* f_in, *f_out;         /* metablites-deiktes se arxeio */
   int bus[53];                /* lewforeio me to polu 53 theseis */
   char license[8];            /* pinakida kykloforias, 7 grammata-arithmoi kai to '\0' */
   int seats;                  /* plithos thesewn */
   char passengerName[40];
   unsigned int passengerSeat;               /*krathmenh thesh (%u)*/
   unsigned short int passengerPhone[10];    /*thlefwno epivath (%hu)*/

   int i, choice, count;       /* boithitikes metablites */

   f_in = fopen("bus.txt", "r"); /* Anoigei to arxeio eisodou*/
   if(f_in == NULL) /* se periptwsi problimatos kata to anoigma */
   {
      printf("To arxeio bus.txt de mporese na anagnwstei\n");
      exit(1);      /* eksodos apo to programma */
   }
   fscanf(f_in,"%s %d %s %u %hu", license, &seats, passengerName, &passengerSeat, passengerPhone); /*edw kollhsa sto pws na kanw thn epanalhyh gia na parei kai tis alles 2 krathmenes theseis*/
   fclose(f_in);                                                                                /* kleisimo arxeiou eisodou */
   printf("%s %d \n %s %u %hu \n", license, seats, passengerName,  passengerSeat, passengerPhone); /* ektypwsi pinakidas, plithous thesewn, epwnumou epivath, thesh kai thlefwno */

   for (i=0;i<seats;i++)
     bus[i]=0;                                    /* arxikopoiisi thesewn lewforeiou */

   choice = 1;                                    /* arxiki timi gia eisodo sto loop */
   while (choice != 0) {                          /* mexri na epilegei termatismos */
      printf("1. emfanish synolikoy plhthous kenwn thesewn kai twn arithmwn  tous\n");
      printf("2. krathsh theshs me sygkekrimeno arithmo\n");
      printf("3. anazhthsh hdh krathmenhs theshs me vash proswpika stoixeia\n");
      printf("4. akyrwsh krathshs theshs me sygkekrimeno arithmo\n");
      printf("5. emfanish listas krathmenwn thesewn taksinomhmenhs kata arithmo theshs\n");
      printf("0. termatismos\n");
      scanf("%d", &choice);
      printf("Epilogi: %d\n",choice);

      switch(choice)
      {

        case 1:
           count = 0;   /* arxikopoiisi metriti */
           for (i=0;i<seats;i++)
              if (bus[i] == 0) count++; /* an thesi eleutheri, auksise to metriti */
           /* tha mporousame anti na metrame kathe fora tis kenes theseis,
           na kratame se metabliti to plithos twn kenwn thesewn kai na tin
           enimerwnoume gia kathe kratisi / apodesmeusi */
           printf("Plithos kenwn thesewn = %d apo %d\n Arithmoi thesewn:\n",count,seats);
           for (i=0;i<seats;i++)
              if (bus[i] == 0)                /* an thesi eleutheri */
                printf("%d ",i+1);            /* typwse ton arithmo tis */
           printf("\n");

           break;

        case 2:
           printf("dwse arithmo thesis\n");
           scanf(" %d", &i);

           if (i<1 || i>seats) {                                    /* elegxos oti arithmos thesis entos oriwn */
              printf("arithmos thesis ektos oriwn\n");
           }
           else if (bus[i-1] == 0) {                                /* an einai eleutheri */
                  bus[i-1] =1;                                      /* kratise tin */
                  printf("thesi kratithike\n");
                  printf("\n");
                  printf("Epwnumo epivath\n");
          scanf("%s",passengerName);
          printf("H thesh sas %s einai h  %d", &passengerName,i);
          printf("\n");
               }

           else if (bus[i-1] != 0)                                  /* an thesi kratimeni */
                  printf("thesi kateilimmeni\n");

           break;

        case 3:
         printf("Stoixeia epivath\n");                               /*o epivaths dinei to epwnumo kai to thlefwno tou*/
         scanf ("%s %hu", &passengerName, &passengerPhone);
         if (*passengerName==NULL)                                   /*an uparxei sth vash dedomenwn tha vgei kai to katallhlo munhma*/
            printf("O sugkekrimenos epivaths den uparxei sth vash dedomenwn\n");
        else if (*passengerName!=0)
            printf ("O epivaths exei krathsei thn thesh %d",i);
           break;

        case 4:
           printf("dwse arithmo thesis\n");
           scanf("%d", &i);
           if (i<1 || i>seats)   /* elegxos oti arithmos thesis entos oriwn */
              printf("arithmos thesis ektos oriwn\n");

           else if (bus[i-1] != 0) { /* an thesi kratimeni */
                  bus[i-1] = 0;    /* apodesmeuse tin */
                  printf("thesi apodesmeutike\n");
                }
                else
                  printf("thesi idi eleutheri\n");

           break;

        case 5:
           printf("kratimenes theseis\n");

          choice = 1;                                    /* arxiki timi gia eisodo sto loop */
          while (choice != 0) {                          /* mexri na epilegei termatismos */
            printf("1.kata thesi\n");
            printf("2.kata onoma\n");
            scanf("%d", &choice);
            printf("Epilogi: %d\n",choice);

      switch(choice)
      {
           case 1:
               printf("kata thesh\n");

           for (i=0;i<seats;i++)
              if (bus[i] != 0)                 /* an thesi kratimeni */
           printf("%d ",i+1);                  /* tupwse tin */
           printf(" \n");
           break;

           case 2:
            printf("dwse onoma\n");
            scanf(" &s",&passengerName);
            printf("taksinomhsh:\n");        /*edw kaloume thn struct passenger sthn opoia exoume apothikeusei olous tous epivates kai ta stoixeia tous*/
            exit(1);
           break;

           default:
           printf("epelekse 1 h' 2\n");
      }}

         case 0:  /* min kaneis tipote */

           f_out = fopen("layout.txt", "w"); /* Anoigei to arxeio ejodou*/
           if(f_out == NULL) /* se periptwsi problimatos kata to anoigma */
           {
              printf("To arxeio layout.txt den mporese na anoixtei\n");
              exit(1);
           break;

        default:
           printf("akatallili epilogi\n");

           }
      }
    }

           }


text:
+++
date = "2017-07-27T08:09:26-07:00"
title = "A Rant on Usable Security"
author = "Jessica Frazelle"
description = "The past, present, and future of usable security. With a focus on containers."
+++

I recently gave a talk at DevOps Days
([slides](https://docs.google.com/a/jessfraz.com/presentation/d/1QnakgUC8AaNydPZCmKGYYja8gs2WoHbHRSjioIVdD9g/edit?usp=drivesdk))
and it had a pretty great response. I'm still pretty care-mad about the topics
it covered so I figured I would turn some key points from it into a blog post.

The overall outline of the talk covered the past, present, and future of
usable security. Let's start with the past.

## The Past

A lot of the security tooling of the past (that we still use today)
require users to jump through a lot of hoops or learn a hard to grok interface.
One of the examples I used was GPG. Contrary to popular opinion, I actually
don't find GPG entirely unusable. I obviously agree that it could be easier
to use, rotate keys, revoke keys blah blah blah. While I find it not exactly
terrible, I can see and completely understand why the majority of
criticism I hear about GPG is that it is hard to use.

There is a point at which better security comes at the expense of convenience.
This needs to stop happening. Stop compromising convenience for security.
Instead find the right balance between the two. Doing this takes collaboration
from both security engineers and software engineers.

Dave Cheney recently had a great tweet.

Why is all software shit? Today I discovered the @duosec API returns 200 even if someone denies the 2fa request.
— Dαve Cheney (@davecheney) July 25, 2017

I love this tweet because it reeks of the stench that only security engineers
built this API. Most software engineers I know would decide to use an HTTP
status code... I mean that's what they are for. ;)

When you combine expertise in different areas you build better products. This is
not rocket science. However egos tend to get in the way as well as biases
towards people who know and like the same things you do. I assure you,
though, when security and software engineers work together
truly usable security will be the outcome.

## The Present

A lot of the content for this portion of the talk focused on how containers make
securing your infrastructure easier. I will touch on some of that but if you
wish to know more you should checkout the
[slides](https://docs.google.com/a/jessfraz.com/presentation/d/1QnakgUC8AaNydPZCmKGYYja8gs2WoHbHRSjioIVdD9g/edit?usp=drivesdk)
or some of my other blog posts on container security.

Two key features in Docker are the default AppArmor and Seccomp profiles.
AppArmor and Seccomp are Linux Security Modules that are not exactly usable
by someone who is unfamiliar with either.

AppArmor can control and audit various process actions such as file
(read, write, execute, etc) and system functions (mount, network tcp, etc).
It has its own meta language, so to speak, and I actually have a repo that changes
the docs for it to more a readable format via a cron job:
[github.com/jessfraz/apparmor-docs](https://github.com/jessfraz/apparmor-docs).
The default profile for AppArmor does super sane things like preventing writing to
`/proc/{num}`, `/proc/sys`, `/sys` and preventing `mount` to name a few.

Syscall filters allow an application to define
what syscalls it allows or denies. The default in Docker is a whitelist that I
initially wrote. Some of the key things it blocks are:

- `add_key`, `keyctl`, `request_key`: Prevent containers from using the kernel
keyring, which is not namespaced. I wrote a blog post on
[Two Objects not Namespaced by the Linux Kernel](https://blog.jessfraz.com/post/two-objects-not-namespaced-linux-kernel/)
and the keyring was one I mentioned.
- `clone`, `unshare`: Deny cloning new namespaces. Also gated by `CAP_SYS_ADMIN`
for `CLONE_*` flags, except `CLONE_USERNS`. I specifically wanted to block
cloning new user namespaces inside containers because they are notorious
for being points of entry for kernel bugs.

There also is an
[entire document that I started in the docker repo](https://github.com/moby/moby/blob/52f32818df8bad647e4c331878fa44317e724939/docs/security/seccomp.md#syscalls-blocked-by-the-default-profile)
that outlines what we block and why.

Having written the default seccomp profile for Docker I am pretty familiar with
how hard this would be for other people. It requires a deep knowledge of the
application being contained and the syscalls it requires. This was also a quite
terrifying feature to add to Docker. When I added it, Docker was already very
popular and if anything would break in a big way it would be on the front page
of hacker news and all the maintainers would have a very bad day. So turning
on something that will `EPERM` by default if we left out any important syscall
is terrifying. I had stress nightmares for weeks. In the end everything went
much smoother than I feared but that was also after HEAVY HEAVY testing. Luckily
I run super obscure things in containers so I even caught that we left out `send`
and `recv` right before the release by running Skype (a 32 bit application) in
a container.

By making a default for all containers, we can secure a very large amount of
users without them even realizing it's happening. This leads perfectly into
my ideas for the future and continuing this motion of making security
on by default and invisible to users.

## The Future

I tend to have pretty weird brain child ideas and this is one of them.
I started thinking about where else a kernel feature like seccomp could easily
be integrated and used by a large number of people. The answer is...
programming languages. I do work with the Go team and as a full content warning
none of this crazy that follows is in any way endorsed by them. ;)

The idea I had is to do **build-time generated** seccomp filters that will be
**applied on run**.

#### Why generate seccomp filters at **build-time**?

Generating security filters/profiles at runtime has been done in the past
& failed... over and over and over again. Something is always missed while
profiling the application. You cannot guarantee that everything that your
application will do will be called while in this profiling phase. Unless of
course you have 100% test coverage, which if you do: Good For You. When the
"thing that was missed" is called and blocked, users will just turn off the
"security." This happens all the time with things like SELinux and AppArmor.

By generating filters at build-time we can ensure ALL code is included in the
filter. I wrote a POC of this and I showed it at
[Kiwicon](https://kiwicon.org/the-con/talks/#e253).

There are three problems though.

1. Executing other binaries. I can't know what syscalls the binary being called
is going to use so we are back at square one.

    ```
    package main

    import (
        "fmt"
        "log"
        "os/exec"
    )

    func main() {
        cmd := exec.Command("myprogram")
        out, err := cmd.CombinedOutput()
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%s\n", out)
    }
    ```

2. Plugins. This problem is solvable in that _if_ this feature was to exist
we could export at the plugin build time the seccomp filters to a
field in the ELF binary or something similar.

    ```
    func main() {
        p, err := plugin.Open("plugin_name.so")
        if err != nil {
            log.Fatal(err)
        }
        v, err := p.Lookup("V")
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%#v\n", v)
    }
    ```

3. Sending arbitrary arguments to `syscall.RawSyscall` and similar.

    ```
    func main() {
        if len(os.Args) <= 3 {
            log.Fatal("must pass 4 arguments to syscall.RawSyscall")
        }
        r1, r2, errno := syscall.RawSyscall(strToUintptr(os.Args[0]),
            strToUintptr(os.Args[1]),
            strToUintptr(os.Args[2]),
            strToUintptr(os.Args[3]))
        if errno != 0 {
            log.Fatalf("errno: %#v", errno)
        }
        fmt.Printf("r1: %#v\nr2: %#v\n", r1, r2)
    }
    func strToUintptr(s string) uintptr {
        return *(*uintptr)(unsafe.Pointer(&s))
    }
    ```

While this is not perfect by any stretch of the imagination I believe it should
open your mind to what _could_ be possible in the future. Hopefully my dream
of making binaries sandbox themselves will eventually get there. I know I won't
stop until it does. ;) Overall, I would like you to remember to find the
right balance between secure AND usable. Don't break users and get security
engineering and software engineering working together!

redpajama_set_name: RedPajamaGithub


text:
'use strict';

var getDescriptors = require('../');
getDescriptors.shim();

var test = require('tape');
var defineProperties = require('define-properties');
var runTests = require('./tests');
var isEnumerable = Object.prototype.propertyIsEnumerable;
var functionsHaveNames = function f() {}.name === 'f';

test('shimmed', function (t) {
	t.equal(Object.getOwnPropertyDescriptors.length, 1, 'Object.getOwnPropertyDescriptors has a length of 1');
	t.test('Function name', { skip: !functionsHaveNames }, function (st) {
		st.equal(Object.getOwnPropertyDescriptors.name, 'getOwnPropertyDescriptors', 'Object.getOwnPropertyDescriptors has name "getOwnPropertyDescriptors"');
		st.end();
	});

	t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
		et.equal(false, isEnumerable.call(Object, 'getOwnPropertyDescriptors'), 'Object.getOwnPropertyDescriptors is not enumerable');
		et.end();
	});

	var supportsStrictMode = (function () { return typeof this === 'undefined'; }());

	t.test('bad object/this value', { skip: !supportsStrictMode }, function (st) {
		st.throws(function () { return getDescriptors(undefined, 'a'); }, TypeError, 'undefined is not an object');
		st.throws(function () { return getDescriptors(null, 'a'); }, TypeError, 'null is not an object');
		st.end();
	});

	runTests(Object.getOwnPropertyDescriptors, t);

	t.end();
});


text:
package org.sakaiproject.tool.assessment.ui.bean.select;

import java.io.Serializable;

import java.util.ArrayList;

import org.sakaiproject.component.api.ServerConfigurationService;
import org.sakaiproject.component.cover.ComponentManager;

/**
 * @author Lance Speelmon
 * @version $Id$
 *
 * Used to be org.navigoproject.ui.web.asi.select.SelectAssessmentForm.java
 */
public class SelectAssessmentBean
implements Serializable
{
	private ArrayList takeableAssessments;

	/** Use serialVersionUID for interoperability. */
	private final static long serialVersionUID = 7401578412639293693L;
	private ArrayList lateHandlingAssessments;
	private ArrayList reviewableAssessments;
	private ArrayList nonReviewableAssessments;
	private String reviewableSortOrder="title";
	private String takeableSortOrder ="title";
	private boolean takeableAscending = true;
	private boolean reviewableAscending = true;
	private org.sakaiproject.tool.assessment.ui.model.PagingModel reviewPager;
	private org.sakaiproject.tool.assessment.ui.model.PagingModel takePager;
	private boolean hasHighestMultipleSubmission = false;  // this is used to display the message on the bottom if there are any highest multiple submissions.
	private boolean hasAnyAssessmentBeenModified = false;  // this is used to display the message on the bottom if there is any assessment been modified after submitted.
	private Boolean warnUserOfModification;
	private boolean hasAnyAssessmentRetractForEdit = false;  // this is used to display the message on the bottom if there is any assessment retracted for edit.
	private String displayAllAssessments = "2"; // display all
	private boolean hasAverageMultipleSubmissions=false;
	private String secureDeliveryHTMLFragments;
	private static final ServerConfigurationService serverConfigurationService= (ServerConfigurationService) ComponentManager.get( ServerConfigurationService.class );

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @return ArrayLists of DeliveryBean objects
	 */
	public ArrayList getTakeableAssessments()
	{
		return takeableAssessments;
	}

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @param takeableAssessments ArrayLists of DeliveryBean objects
	 */
	public void setTakeableAssessments(ArrayList takeableAssessments)
	{
		this.takeableAssessments = takeableAssessments;
	}

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @return ArrayLists of DeliveryBean objects
	 */
	public ArrayList getLateHandlingAssessments()
	{
		return lateHandlingAssessments;
	}

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @param lateHandlingAssessments ArrayLists of DeliveryBean objects
	 */
	public void setLateHandlingAssessments(ArrayList lateHandlingAssessments)
	{
		this.lateHandlingAssessments = lateHandlingAssessments;
	}

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @return ArrayLists of DeliveryBean objects
	 */
	public ArrayList getReviewableAssessments()
	{
		return reviewableAssessments;
	}

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @param reviewAssessments ArrayLists should be lists of DeliveryBean objects
	 */
	public void setReviewableAssessments(ArrayList reviewableAssessments)
	{
		this.reviewableAssessments = reviewableAssessments;
	}

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @return ArrayLists of DeliveryBean objects
	 */
	public ArrayList getNonReviewableAssessments()
	{
		return this.nonReviewableAssessments;
	}

	/**
	 * ArrayLists should be lists of DeliveryBean objects
	 *
	 * @param nonReviewableAssessments ArrayLists should be lists of DeliveryBean objects
	 */
	public void setNonReviewableAssessments(ArrayList nonReviewableAssessments)
	{
		this.nonReviewableAssessments = nonReviewableAssessments;
	}

	////////////////////////////////////////////////////////////////
	// not used right now
	public org.sakaiproject.tool.assessment.ui.model.PagingModel getReviewPager() {
		return reviewPager;
	}
	public void setReviewPager(org.sakaiproject.tool.assessment.ui.model.PagingModel reviewPager) {
		this.reviewPager = reviewPager;
	}
	public org.sakaiproject.tool.assessment.ui.model.PagingModel getTakePager() {
		return takePager;
	}
	public void setTakePager(org.sakaiproject.tool.assessment.ui.model.PagingModel takePager) {
		this.takePager = takePager;
	}

	// sorting model
	/**
	 * sort order for review table
	 * @return
	 */
	public String getReviewableSortOrder()
	{
		return reviewableSortOrder;
	}

	/**
	 * ascending descending for review table
	 * @return
	 */
	public boolean isReviewableAscending()
	{
		return reviewableAscending;
	}

	/**
	 * sort for take assessment table
	 * @return
	 */

	public String getTakeableSortOrder()
	{
		return takeableSortOrder;
	}

	/**
	 * sort for take assessment table
	 * @param sort
	 */
	public void setTakeableSortOrder(String takeableSortOrder)
	{
		this.takeableSortOrder = takeableSortOrder;
	}

	/**
	 * sort for review assessment table
	 * @param sort
	 */
	public void setReviewableSortOrder(String reviewableSortOrder)
	{
		this.reviewableSortOrder = reviewableSortOrder;
	}
	/**
	 *
	 * @param reviewableAscending
	 */
	public void setReviewableAscending(boolean reviewableAscending)
	{
		this.reviewableAscending = reviewableAscending;
	}
	/**
	 * is takable table sorted in ascending order
	 * @return true if it is
	 */
	public boolean isTakeableAscending()
	{
		return takeableAscending;
	}

	/**
	 *
	 * @param takeableAscending is takable table sorted in ascending order
	 */
	public void setTakeableAscending(boolean takeableAscending)
	{
		this.takeableAscending = takeableAscending;
	}

	public boolean getIsThereAssessmentToTake()
	{
		if(takeableAssessments==null || takeableAssessments.size()==0)

			return false;
		else
			return true;
	}

	public boolean getIsThereAssessmentToReview()
	{

		if(reviewableAssessments==null || reviewableAssessments.size()==0)

			return false;
		else
			return true;
	}

	/**
	 * @return Returns the hasHighestMultipleSubmission.
	 */
	public boolean isHasHighestMultipleSubmission() {
		return hasHighestMultipleSubmission;
	}

	/**
	 * @param hasHighestMultipleSubmission The hasHighestMultipleSubmission to set.
	 */
	public void setHasHighestMultipleSubmission(boolean hasHighestMultipleSubmission) {
		this.hasHighestMultipleSubmission = hasHighestMultipleSubmission;
	}

	public boolean getHasAnyAssessmentBeenModified() {
		return hasAnyAssessmentBeenModified;
	}

	public void setHasAnyAssessmentBeenModified(boolean hasAnyAssessmentBeenModified) {
		this.hasAnyAssessmentBeenModified = hasAnyAssessmentBeenModified;
	}

	public boolean getHasAnyAssessmentRetractForEdit() {
		return hasAnyAssessmentRetractForEdit;
	}

	public void setHasAnyAssessmentRetractForEdit(boolean hasAnyAssessmentRetractForEdit) {
		this.hasAnyAssessmentRetractForEdit = hasAnyAssessmentRetractForEdit;
	}

	public String getDisplayAllAssessments() {
		return displayAllAssessments;
	}

	public void setDisplayAllAssessments(String displayAllAssessments) {
		this.displayAllAssessments = displayAllAssessments;
	}

	/**
	 * @return Returns the hasAvergeMultipleSubmission.
	 */
	public boolean isHasAverageMultipleSubmissions() {
		return hasAverageMultipleSubmissions;
	}

	/**
	 * @param Average tMultipleSubmission The hasAverageMultipleSubmission to set.
	 */
	public void setHasAverageMultipleSubmissions(boolean hasAverageMultipleSubmissions) {
		this.hasAverageMultipleSubmissions = hasAverageMultipleSubmissions;
	}

	public Boolean getWarnUserOfModification() {
		if(warnUserOfModification == null){
			warnUserOfModification = serverConfigurationService.getBoolean("samigo.SelectAssessmentBean.warnUserOfModification", true);
		}
		return warnUserOfModification;
	}

	public void setWarnUserOfModification(Boolean warnUserOfModification) {
		this.warnUserOfModification = warnUserOfModification;
	}

	public String getSecureDeliveryHTMLFragments() {
		return secureDeliveryHTMLFragments;
	}

	public void setSecureDeliveryHTMLFragments(String secureDeliveryHTMLFragments) {
		this.secureDeliveryHTMLFragments = secureDeliveryHTMLFragments;
	}
}


text:
@extends('layouts.main')
@section('title', 'Welcome')
@section('content')

PageWeb

Create Amazing & Self-Updating Websites from your Facebook Page & other Social Networks Instantly

                <form action="{{ URL::route('sites.create.preview') }}" method="post">

                            <button class="btn btn-lg btn-facebook" type="button"></button>

                        <input  type="text" name="url" placeholder="Enter Your Facebook Page URL" class="form-control input-lg bg-white" />

                            <button class="btn btn-lg btn-danger" type="submit">Preview</button>

                </form>

What You Get

We have done a lot of things, and put them inside squared boxes for you

Self-updating Website

Save yourself hours. Every update your make on your Facebook Page automatically updates your website

Get More Traffic

Give people another options to find out what you are doing. Appear high in search engines

Custom Domains

Give your readers something short and easy to remember with a .com, .net, .org., .me, or .co domain name.

Save Money

Starting with just $8 a month, you can save a lot from a website that you barely visit and update.

Go Mobile

Today everything is mobile - now you can be too! Once you create a website, a matching mobile site will automatically be generated.

Safe and Secure

Your site is hosted on our servers spread across multiple data centers. That way, it's super fast and always available.

@stop